002_Python_Classes_and_Objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Object Class** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/06_Python_Object_Class)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python  Classes and Objects\n",
    "\n",
    "In this class, you will learn about the core functionality of Python objects and classes. You'll learn what a class is, how to create it and use it in your program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Classes and Objects\n",
    "\n",
    "Python is an object oriented programming language. Everything in Python is an object, with its properties and methods. A number, string, list, dictionary, tuple, set etc. used in a program is an object of a corresponding built-in class. We create class to create an object. Unlike procedure oriented programming, where the main emphasis is on functions, object oriented programming stresses on objects.\n",
    "\n",
    "An object is simply a collection of data (variables) and methods (functions) that act on those data. Similarly, a class is a blueprint for that object.\n",
    "\n",
    "We can think of class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows etc. Based on these descriptions we build the house. House is the object.\n",
    "\n",
    "As many houses can be made from a house's blueprint, we can create many objects from a class. An object is also called an instance of a class and the process of creating this object is called **instantiation**. We instantiate a class to create an object. The class defines attributes and the behavior of the object, while the object, on the other hand, represents the class.\n",
    "\n",
    "We have been working with classes and objects right from the beginning of this challenge unknowingly. Every element in a Python program is an object of a class. Let us check if everything in python is a class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "➡ 10 belongs to <class 'int'>\n",
      "➡ 'string' belongs to <class 'str'>\n",
      "➡ True belongs to <class 'bool'>\n",
      "➡ [1,2,3] belongs to <class 'list'>\n",
      "➡ (1,2,3) belongs to <class 'tuple'>\n",
      "➡ {1,2,3} belongs to <class 'set'>\n",
      "➡ {1:'A', 2:'B'} belongs to <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "num = 10\n",
    "print(\"➡ 10 belongs to\",type(num))           # <class 'int'>\n",
    "\n",
    "string = 'string'\n",
    "print(\"➡ 'string' belongs to\",type(string))  # <class 'str'>\n",
    "\n",
    "boolean = True\n",
    "print(\"➡ True belongs to\",type(boolean))     # <class 'bool'>\n",
    "\n",
    "list_1 = [1,2,3]\n",
    "print(\"➡ [1,2,3] belongs to\",type(list_1))   # <class 'list'>\n",
    "\n",
    "tuple_1 = (1,2,3)\n",
    "print(\"➡ (1,2,3) belongs to\",type(tuple_1))  # <class 'tuple'>\n",
    "\n",
    "set_1 = {1,2,3}\n",
    "print(\"➡ {1,2,3} belongs to\",type(set_1))    # <class 'set'>\n",
    "    \n",
    "dict_1 = {1:'A', 2:'B'}\n",
    "print(\"➡ {1:'A', 2:'B'} belongs to\",type(dict_1))  # <class 'dict'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a Class in Python\n",
    "\n",
    "Like function definitions begin with the **[def](https://github.com/milaan9/01_Python_Introduction/blob/main/Python_Keywords_List.ipynb)** keyword in Python, class definitions begin with a **[class](https://github.com/milaan9/01_Python_Introduction/blob/main/Python_Keywords_List.ipynb)** keyword.\n",
    "\n",
    "The first string inside the class is called docstring and has a brief description about the class. Although not mandatory, this is highly recommended.\n",
    "\n",
    "Here is a simple class definition.\n",
    "\n",
    "```python\n",
    "class MyNewClass:\n",
    "    '''This is a docstring. I have created a new class'''\n",
    "    pass\n",
    "```\n",
    "\n",
    "A class creates a new local **[namespace](https://github.com/milaan9/01_Python_Introduction/blob/main/013_Python_Namespace_and_Scope.ipynb)** where all its attributes are defined. Attributes may be data or functions.\n",
    "\n",
    "There are also special attributes in it that begins with double underscores **`__`**. For example, **`__doc__`** gives us the docstring of that class.\n",
    "\n",
    "As soon as we define a class, a new class object is created with the same name. This class object allows us to access the different attributes as well as to instantiate new objects of that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:50.823644Z",
     "start_time": "2021-06-20T19:09:50.811928Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<function Person.greet at 0x000001D8AEC3AC10>\n",
      "This is a person class\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Creating Class and Object in Python\n",
    "\n",
    "class Person:\n",
    "    \"This is a person class\"\n",
    "    age = 10\n",
    "\n",
    "    def greet(self):\n",
    "        print('Hello')\n",
    "\n",
    "print(Person.age)      # Output: 10\n",
    "\n",
    "print(Person.greet)    # Output: <function Person.greet>\n",
    "\n",
    "print(Person.__doc__)  # Output: 'This is my second class'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating an Object in Python\n",
    "\n",
    "We saw that the class object could be used to access different attributes.\n",
    "\n",
    "It can also be used to create new object instances (instantiation) of that class. The procedure to create an object is similar to a [**function**](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb) call.\n",
    "\n",
    "```python\n",
    "harry = Person()\n",
    "```\n",
    "This will create a new object instance named **`harry`**. We can access the attributes of objects using the object name prefix.\n",
    "\n",
    "Attributes may be data or method. Methods of an object are corresponding functions of that class.\n",
    "\n",
    "This means to say, since **`Person.greet`** is a function object (attribute of class), **`Person.greet`** will be a method object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:52.160548Z",
     "start_time": "2021-06-20T19:09:52.140040Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function Person.greet at 0x000001D8AEC7E4C0>\n",
      "<bound method Person.greet of <__main__.Person object at 0x000001D8AEC44EB0>>\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    \"This is a person class\"\n",
    "    age = 10\n",
    "\n",
    "    def greet(self):\n",
    "        print('Hello')\n",
    "\n",
    "# create a new object of Person class\n",
    "harry = Person()\n",
    "\n",
    "print(Person.greet)  # Output: <function Person.greet>\n",
    "\n",
    "print(harry.greet)  # Output: <bound method Person.greet of <__main__.Person object>>\n",
    "\n",
    "# Calling object's greet() method\n",
    "harry.greet()  # Output: Hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "You may have noticed the **`self`** parameter in function definition inside the class but we called the method simply as **`harry.greet()`** without any [**arguments**](https://github.com/milaan9/04_Python_Functions/blob/main/004_Python_Function_Arguments.ipynb). It still worked.\n",
    "\n",
    "This is because, whenever an object calls its method, the object itself is passed as the first argument. So, **`harry.greet()`** translates into **`Person.greet(harry)`**.\n",
    "\n",
    "In general, calling a method with a list of n arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method's object before the first argument.\n",
    "\n",
    "For these reasons, the first argument of the function in class must be the object itself. This is conventionally called self. It can be named otherwise but we highly recommend to follow the convention.\n",
    "\n",
    "Now you must be familiar with class object, instance object, function object, method object and their differences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructors in Python\n",
    "\n",
    "In Python, if a class functions that begin with double underscore **`__`** are called special functions as they have special meaning.\n",
    "\n",
    "A class without a constructor is not really useful in real applications. A constructor is a special type of method used in Python to initialize the object of a Class. The constructor will be executed automatically when the object is created. If we create three objects, the constructor is called three times and initialize each object.\n",
    "\n",
    "The main purpose of the constructor is to declare and initialize instance variables. It can take at least one argument that is **`self`**. The **`__init__()`** method is called the constructor in Python. In other words, the name of the constructor should be **`__init__(self)`**.\n",
    "\n",
    "**A constructor is optional, and if we do not provide any constructor, then Python provides the default constructor. Every class in Python has a constructor, but it’s not required to define it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:53.713272Z",
     "start_time": "2021-06-20T19:09:53.699603Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5+6j\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class ComplexNumber:\n",
    "    def __init__(self,r=0,i=1):\n",
    "        self.real=r;\n",
    "        self.imag=i;\n",
    "\n",
    "    def getData(self):\n",
    "        print('{0}+{1}j'.format(self.real,self.imag))\n",
    "\n",
    "\n",
    "c1=ComplexNumber(5,6)\n",
    "c1.getData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:54.928101Z",
     "start_time": "2021-06-20T19:09:54.603889Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2+3j\n",
      "(5, 0, 10)\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'ComplexNumber' object has no attribute 'attr'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-05908a030c74>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[1;31m# but c1 object doesn't have attribute 'attr'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattr\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# AttributeError: 'ComplexNumber' object has no attribute 'attr'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'ComplexNumber' object has no attribute 'attr'"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "class ComplexNumber:\n",
    "    def __init__(self, r=0, i=0):\n",
    "        self.real = r\n",
    "        self.imag = i\n",
    "\n",
    "    def get_data(self):\n",
    "        print(f'{self.real}+{self.imag}j')\n",
    "\n",
    "# Create a new ComplexNumber object\n",
    "num1 = ComplexNumber(2, 3)\n",
    "\n",
    "# Call get_data() method\n",
    "\n",
    "num1.get_data()   # Output: 2+3j\n",
    "\n",
    "# Create another ComplexNumber object and create a new attribute 'attr'\n",
    "num2 = ComplexNumber(5)\n",
    "num2.attr = 10\n",
    "\n",
    "print((num2.real, num2.imag, num2.attr))  # Output: (5, 0, 10)\n",
    "\n",
    "# but c1 object doesn't have attribute 'attr'\n",
    "print(num1.attr)  # AttributeError: 'ComplexNumber' object has no attribute 'attr'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above example, we defined a new class to represent complex numbers. It has two functions, **`__init__()`** to initialize the variables (defaults to zero) and **`get_data()`** to display the number properly.\n",
    "\n",
    "An interesting thing to note in the above step is that attributes of an object can be created on the fly. We created a new attribute **`attr`** for object **`num2`** and read it as well. But this does not create that attribute for object **`num1`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of Constructors\n",
    "\n",
    "We have two types of constructors in Python:\n",
    "\n",
    "* **Non-parameterized:** The constructors in Python which have no parameter is known as a non parameterized constructor. The non-parameterized constructor uses when we do not want to manipulate the value or the constructor that has only self as an argument.\n",
    "* **Parameterized Constructor:** The constructor with parameters is known as a parameterized constructor. The parameterized constructor has multiple parameters along with the self."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:57.889505Z",
     "start_time": "2021-06-20T19:09:57.874860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is non parametrized constructor\n",
      "Hello Arthur\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Constructor without parameters (Non-parameterized)\n",
    "\n",
    "class Test:\n",
    "    # Constructor - non parameterized\n",
    "    def __init__(self):\n",
    "        print(\"This is non parametrized constructor\")\n",
    "\n",
    "    def show(self, name):\n",
    "        print(\"Hello\", name)\n",
    "\n",
    "# creating object of the class\n",
    "t = Test()         # Output:This is non parametrized constructor\n",
    "\n",
    "# calling the instance method\n",
    "t.show(\"Arthur\")   # Output Hello Arthur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:09:59.101408Z",
     "start_time": "2021-06-20T19:09:59.082857Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is parametrized constructor\n",
      "Fruit is Apple and Color is red\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Constructor with parameters\n",
    "\n",
    "class Fruit:\n",
    "    # parameterized constructor\n",
    "    def __init__(self, name, color):\n",
    "        print(\"This is parametrized constructor\")\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Fruit is\", self.name, \"and Color is\", self.color)\n",
    "\n",
    "# creating object of the class\n",
    "# this will invoke parameterized constructor\n",
    "obj = Fruit(\"Apple\", \"red\")   # Output This is parametrized constructor\n",
    "\n",
    "# calling the instance method using the object\n",
    "obj.show()                    # Output Fruit is Apple and Color is red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:** \n",
    "\n",
    "In the above example, we create a **parameterized constructor** with parameters **`name`** and **`color`**. When we create an object of **`Test`** class called **`obj`**, the parameterized constructor will be executed automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:00.225422Z",
     "start_time": "2021-06-20T19:10:00.204916Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is parametrized constructor\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "class Student:\n",
    "    # Constructor - parameterized\n",
    "    def __init__(self, name):\n",
    "        print(\"This is parametrized constructor\")\n",
    "        self.name = name\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Hello\",self.name)\n",
    "\n",
    "student = Student(\"World\")\n",
    "student.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:00.807450Z",
     "start_time": "2021-06-20T19:10:00.791827Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jane is a students\n",
      "Bella is also a students\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Creating Class and Object in Python\n",
    "\n",
    "class MasterStudentClass:\n",
    "    # class attribute\n",
    "    species = \"students\"\n",
    "\n",
    "    # instance attribute\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "# instantiate the Parrot class\n",
    "jane = MasterStudentClass(\"Jane\", 18)\n",
    "bella = MasterStudentClass(\"Bella\", 19)\n",
    "candy = MasterStudentClass(\"Candy\", 17)\n",
    "lucia = MasterStudentClass(\"Lucia\", 18)\n",
    "ran = MasterStudentClass(\"Ran\", 20)\n",
    "\n",
    "# access the class attributes\n",
    "print(\"Jane is a {}\".format(jane.__class__.species))         # Jane is a students\n",
    "print(\"Bella is also a {}\".format(bella.__class__.species))  # Bella is also a students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:01.192212Z",
     "start_time": "2021-06-20T19:10:01.180495Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :  Mark , Id :  101\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "class Student:\n",
    "    \n",
    "    # class attribute\n",
    "    'Common base class for all students'\n",
    "    student_count=0\n",
    "\n",
    "    def __init__(self, name, id):  # check the number of underscore '_' used\n",
    "        self.name = name\n",
    "        self.id = id\n",
    "        Student.student_count+=1\n",
    "\n",
    "    def printStudentData(self):\n",
    "        print (\"Name : \", self.name, \", Id : \", self.id)\n",
    "\n",
    "s=Student(\"Mark\",101)\n",
    "s.printStudentData()  # Name :  Mark , Id :  101"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "* The variable **`student_count`** is a class variable whose value is shared among all the instances of a in this class. This can be accessed as **`Student.student_count`** from inside the class or outside the class.\n",
    "\n",
    "* The first method **`__init__()`** is a special method, which is called class **constructor** or **initialization** method that Python calls when you create a new instance of this class.\n",
    "\n",
    "* You declare other class methods like normal functions with the exception that the first argument to each method is self. Python adds the self argument to the list for you; you do not need to include it when you call the methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Instance Objects\n",
    "\n",
    "To create instances of a class, you call the class using class name and pass in whatever arguments its **`__init__`** method accepts. \n",
    "Lets Create Studnet class object of above example : \n",
    "\n",
    "```python\n",
    "std=Student('Vijay','102')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Attributes with `self` Parameter\n",
    "\n",
    "The **`self`** is used to represent the instance of the class. It is the default variable that is always pointing to the current object.\n",
    "\n",
    "By using **`self`**, we can access the instance variable and instance method of the object. While defining constructor and instance method, the **`self`** is their first parameter.\n",
    "\n",
    "It’s not required the first parameter named to be **`self`**, we can give any name whatever we like, but it has to be the first parameter of any function in the class.\n",
    "\n",
    "You access the object's attributes using the dot operator with object. Class variable would be accessed using class name as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:03.478324Z",
     "start_time": "2021-06-20T19:10:03.459773Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee ID is  19116 and name is Amy\n",
      "Employee of IT department\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self, id, name):\n",
    "        # instance variable\n",
    "        self.id = id\n",
    "        self.name = name\n",
    "    \n",
    "    # instance method\n",
    "    def info(self):\n",
    "        print(\"Employee ID is \", self.id, \"and name is\", self.name)\n",
    "\n",
    "    # instance method \n",
    "    def department(self):\n",
    "        print(\"Employee of IT department\")\n",
    "\n",
    "emp = Employee(19116, \"Amy\", )\n",
    "emp.info()         # Output Employee ID is 19116 and name is Amy\n",
    "\n",
    "emp.department()   # Output Employee of IT department"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:** \n",
    "\n",
    "In the above example, all methods including **`__init__`** have a self parameter. We created two instance variables **`id`** and **`name`**. Then we create an object of a class **`Employee`** called **`emp`** and accessed instance methods of the class called **`info()`** and **`department()`** respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:04.386517Z",
     "start_time": "2021-06-20T19:10:04.363084Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Student :  3\n",
      "Name :  Milan , Id :  101\n",
      "Name :  Vijay , Id :  102\n",
      "Name :  Chirag , Id :  103\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "class Student:\n",
    "    'Common base class for all students'\n",
    "    student_count=0\n",
    "\n",
    "    def __init__(self, name, id):\n",
    "        self.name = name\n",
    "        self.id = id\n",
    "        Student.student_count+=1\n",
    "\n",
    "    def printStudentData(self):\n",
    "        print (\"Name : \", self.name, \", Id : \", self.id)\n",
    "\n",
    "std1=Student(\"Milan\",101)\n",
    "std2=Student(\"Vijay\",102)\n",
    "std3=Student(\"Chirag\",103)\n",
    "\n",
    "print(\"Total Student : \",Student.student_count)\n",
    "std1.printStudentData()\n",
    "std2.printStudentData()\n",
    "std3.printStudentData()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of using the normal statements to access attributes, you can use the following functions:\n",
    "\n",
    "* **`getattr(obj, name[, default])`** − to access the attribute of object. \n",
    "\n",
    "* **`hasattr(obj,name)`** − to check if an attribute exists or not. \n",
    "\n",
    "* **`setattr(obj,name,value)`** − to set an attribute. If attribute does not exist, then it would be created. \n",
    "\n",
    "* **`delattr(obj, name)`** − to delete an attribute. \n",
    "\n",
    "**Example:**\n",
    "\n",
    "```python\n",
    "hasattr(std1, 'id') # Returns true if 'id' attribute exists\n",
    "getattr(std1, 'id') # Returns value of 'id' attribute\n",
    "setattr(std1, 'id', 104) # Set attribute 'id' 104\n",
    "delattr(std1, 'id') # Delete attribute 'id'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-In Class Attributes\n",
    "\n",
    "Every Python class keeps following built-in attributes and they can be accessed using **dot operator** like any other attribute −\n",
    "\n",
    "* **`__dict__`**  : Dictionary containing the class's namespace. \n",
    "* **`__doc__`** : Class documentation string or none, if undefined. \n",
    "* **`__name__`** : Class name. \n",
    "* **`__module__`**  : Module name in which the class is defined. This attribute is **`__main__`** in interactive mode. \n",
    "* **`__bases__`** : A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.\n",
    "\n",
    "let us try to access all these attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:05.676059Z",
     "start_time": "2021-06-20T19:10:05.651650Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Student :  3\n",
      "Student.__doc__: Common base class for all students\n",
      "StudentStudent.__name__: Student\n",
      "Student.__module__: __main__\n",
      "Student.__bases__: (<class 'object'>,)\n",
      "Student.__dict__: {'__module__': '__main__', '__doc__': 'Common base class for all students', 'student_count': 3, '__init__': <function Student.__init__ at 0x000001D8AEC7E1F0>, 'printStudentData': <function Student.printStudentData at 0x000001D8AEC7E5E0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>}\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Student:\n",
    "    'Common base class for all students'\n",
    "    student_count=0\n",
    "\n",
    "    def __init__(self, name, id):\n",
    "        self.name = name\n",
    "        self.id = id\n",
    "        Student.student_count+=1\n",
    "\n",
    "    def printStudentData(self):\n",
    "        print (\"Name : \", self.name, \", Id : \", self.id)\n",
    "\n",
    "std1=Student(\"Milan\",101)\n",
    "std2=Student(\"Vijay\",102)\n",
    "std3=Student(\"Chirag\",103)\n",
    "\n",
    "print(\"Total Student : \",Student.student_count)\n",
    "print (\"Student.__doc__:\", Student.__doc__)\n",
    "print (\"StudentStudent.__name__:\", Student.__name__)\n",
    "print (\"Student.__module__:\", Student.__module__)\n",
    "print (\"Student.__bases__:\", Student.__bases__)\n",
    "print (\"Student.__dict__:\", Student.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object Properties\n",
    "\n",
    "Every object has properties with it. In other words, we can say that object property is an association between **name** and **value**.\n",
    "\n",
    "For example, a car is an object, and its properties are car color, sunroof, price, manufacture, model, engine, and so on. Here, color is the name and red is the **value**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modify Object Properties\n",
    "\n",
    "Every object has properties associated with them. We can set or modify the object’s properties after object initialization by calling the property directly using the dot operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:06.812770Z",
     "start_time": "2021-06-20T19:10:06.803984Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fruit is strawberry and Color is red\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Fruit:\n",
    "    def __init__(self, name, color):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Fruit is\", self.name, \"and Color is\", self.color)\n",
    "\n",
    "# creating object of the class\n",
    "obj = Fruit(\"Apple\", \"red\")\n",
    "\n",
    "# Modifying Object Properties\n",
    "obj.name = \"strawberry\"\n",
    "\n",
    "# calling the instance method using the object obj\n",
    "obj.show()   # Output Fruit is strawberry and Color is red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete object properties\n",
    "\n",
    "We can delete the object property by using the **`del`** keyword. After deleting it, if we try to access it, we will get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:07.719989Z",
     "start_time": "2021-06-20T19:10:07.698507Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Fruit' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-250fe64180f3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     17\u001b[0m \u001b[1;31m# Accessing object properties after deleting\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 18\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# Output: AttributeError: 'Fruit' object has no attribute 'name'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Fruit' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Fruit:\n",
    "    def __init__(self, name, color):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Fruit is\", self.name, \"and Color is\", self.color)\n",
    "\n",
    "# creating object of the class\n",
    "obj = Fruit(\"Apple\", \"red\")\n",
    "\n",
    "# Deleting Object Properties\n",
    "del obj.name\n",
    "\n",
    "# Accessing object properties after deleting\n",
    "print(obj.name)   # Output: AttributeError: 'Fruit' object has no attribute 'name'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete Objects\n",
    "\n",
    "In Python, we can also delete the object by using a **`del`** keyword. An object can be anything like, class object, list, tuple, set, etc.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "del object_name\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:09.470950Z",
     "start_time": "2021-06-20T19:10:09.444584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Department is  IT\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'emp' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-4340020aef34>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;31m# Accessing after delete object\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0memp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# Output : NameError: name 'emp' is not defined\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'emp' is not defined"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Employee:\n",
    "    depatment = \"IT\"\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Department is \", self.depatment)\n",
    "\n",
    "emp = Employee()\n",
    "emp.show()\n",
    "\n",
    "# delete object\n",
    "del emp\n",
    "\n",
    "# Accessing after delete object\n",
    "emp.show()  # Output : NameError: name 'emp' is not defined "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above example, we create the object **`emp`** of the class **`Employee`**. After that, using the **`del`** keyword, we deleted that object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:10.872305Z",
     "start_time": "2021-06-20T19:10:10.843014Z"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'ComplexNumber' object has no attribute 'imag'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-86635ab2cc7e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mnum1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mComplexNumber\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mnum1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimag\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mnum1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-5-05908a030c74>\u001b[0m in \u001b[0;36mget_data\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{self.real}+{self.imag}j'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;31m# Create a new ComplexNumber object\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'ComplexNumber' object has no attribute 'imag'"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "num1 = ComplexNumber(2,3)\n",
    "del num1.imag\n",
    "num1.get_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:11.381090Z",
     "start_time": "2021-06-20T19:10:11.357656Z"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'ComplexNumber' object has no attribute 'get_data'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-b8eab4452d4b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mComplexNumber\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mnum1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'ComplexNumber' object has no attribute 'get_data'"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "del ComplexNumber.get_data\n",
    "num1.get_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even delete the object itself, using the del statement!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:12.993385Z",
     "start_time": "2021-06-20T19:10:12.978737Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'c1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-45d582f31548>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mc1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mComplexNumber\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mc1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mc1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'c1' is not defined"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "c1 = ComplexNumber(1,3)\n",
    "del c1\n",
    "c1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Actually, it is more complicated than that. When we do **`c1 = ComplexNumber(1,3)`**, a new instance object is created in memory and the name **`c1`** binds with it.\n",
    "\n",
    "On the command **`del c1`**, this binding is removed and the name **`c1`** is deleted from the corresponding namespace. The object however continues to exist in memory and if no other name is bound to it, it is later automatically destroyed.\n",
    "\n",
    "This automatic destruction of unreferenced objects in Python is also called garbage collection.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/objr.png\" width=\"450\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Hiding\n",
    "\n",
    "An object's attributes may or may not be visible outside the class definition. You need to name attributes with a double underscore prefix, and those attributes then will not be directly **visible** to outsiders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:15.081745Z",
     "start_time": "2021-06-20T19:10:15.060263Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'JustCounter' object has no attribute '__secretCount'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-59b7b8cc9b5b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__secretCount\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'JustCounter' object has no attribute '__secretCount'"
     ]
    }
   ],
   "source": [
    "class JustCounter:\n",
    "    __secretCount = 0  # private attribute\n",
    "\n",
    "    def count(self):\n",
    "        self.__secretCount += 1\n",
    "        print (self.__secretCount)\n",
    "\n",
    "counter = JustCounter()\n",
    "counter.count()\n",
    "counter.count()\n",
    "print (counter.__secretCount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python protects those members by internally changing the name to include the class name. You can access such attributes as **`object._className__attrName`**. If you would replace your last line as following, then it works for you −"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-20T19:10:16.999698Z",
     "start_time": "2021-06-20T19:10:16.979193Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "class JustCounter:\n",
    "    __secretCount = 0\n",
    "\n",
    "    def count(self):\n",
    "        self.__secretCount += 1\n",
    "        print (self.__secretCount)\n",
    "\n",
    "counter = JustCounter()\n",
    "counter.count()\n",
    "counter.count()\n",
    "# print (counter.__secretCount)  # This wont work\n",
    "print (counter._JustCounter__secretCount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 5, 'b': 7, 'c': {'d': 8}}\n"
     ]
    }
   ],
   "source": [
    "# convert_dictionary_to_python_object\n",
    "\n",
    "class obj(object):\n",
    "    def __init__(self, d):\n",
    "        for x, y in d.items():\n",
    "            setattr(self, x, obj(y) if isinstance(y, dict) else y)\n",
    "data = {'a':5,'b':7,'c':{'d':8}}\n",
    "ob = obj(data)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}