Tutorials/Python_Data_Engineering/3. Python Intermediate/Intermediate - Functions and OOPS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "33419f32",
   "metadata": {},
   "source": [
    "## What are we going to learn today?\n",
    "***\n",
    "- **Modular Programming in Python**\n",
    "    - Functions\n",
    "      - What is a function ?\n",
    "      - `def` statement\n",
    "      - Function arguments\n",
    "      - `return` values\n",
    "      - `lambda` functions<br/><br/>\n",
    "    \n",
    "    - Object Oriented Programming\n",
    "      - Objects\n",
    "      - Class\n",
    "      - Attributes\n",
    "      - Methods\n",
    "      - Instance vs Class vs Static Methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a513409d",
   "metadata": {},
   "source": [
    "# Modular Programming in Python\n",
    "***\n",
    "- Like all programming languages, Python provides various constructs to enable code reuse <br/><br/>\n",
    "\n",
    "- Python provides functions/methods, classes and modules for reuse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2cd468d",
   "metadata": {},
   "source": [
    "\n",
    "## What is a function?\n",
    "***\n",
    "\n",
    "Formally, a function is a useful device that groups together a set of statements so they can be run more than once. We can also specify parameters that can serve as inputs to the functions.\n",
    "\n",
    "On a more fundamental level, functions allow us to not have to repeatedly write the same code again and again. If you remember back to the lessons on strings and lists, remember that we used a function len() to get the length of a string. Since checking the length of a sequence is a common task you would want to write a function that can do this repeatedly at command.\n",
    "\n",
    "Functions will be one of most basic levels of reusing code in Python, and it will also allow us to start thinking of program design (we will dive much deeper into the ideas of design when we learn about Object Oriented Programming).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c773b0",
   "metadata": {},
   "source": [
    "## Function Definition\n",
    "***\n",
    "In the syntax below:\n",
    "- **def** is the keyword used to define functions\n",
    "- arg1...argn, \\*args and \\*\\*kwargs are function parameters (and are optional)\n",
    "- The expression after the `return` keyword is the value returned to the caller (optional)\n",
    "\n",
    "<img src=\"images/py_func.png\">\n",
    "\n",
    "Now lets look at how we can create a function in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "45f00ad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_of_function(arg1,arg2):\n",
    "    '''\n",
    "    This is where the function's Document String (doc-string) goes\n",
    "    '''\n",
    "    # Do stuff here\n",
    "    #return desired result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745e3fbd",
   "metadata": {},
   "source": [
    "## def Statements\n",
    "\n",
    "We begin with def then a \n",
    "space followed by the name of the function. Try to keep names relevant, for example len() is a good name for a length() function. Also be careful with names, you wouldn't want to call a function the same name as a built-in function in Python (such as len).\n",
    "\n",
    "Next come a pair of parenthesis with a number of arguments separated by a comma. These arguments are the inputs for your function. You'll be able to use these inputs in your function and reference them. After this you put a colon.\n",
    "\n",
    "Now here is the important step, you must indent to begin the code inside your function correctly. Python makes use of whitespace to organize code. Lots of other programing languages do not do this, so keep that in mind.\n",
    "\n",
    "Next you'll see the doc-string, this is where you write a basic description of the function. Using iPython and iPython Notebooks, you'll be ab;e to read these doc-strings by pressing Shift+Tab after a function name. Doc strings are not necessary for simple functions, but its good practice to put them in so you or other people can easily understand the code you write.\n",
    "\n",
    "After all this you begin writing the code you wish to execute.\n",
    "\n",
    "The best way to learn functions is by going through examples. So let's try to go through examples that relate back to the various objects and data structures we learned about before."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14107dd6",
   "metadata": {},
   "source": [
    "### Example 1: A simple print 'hello' function\n",
    "In this example we take our first steps to write a working function which prints out 'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f052cc60",
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_my_name():\n",
    "    print(\"Darshil\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "66c32757",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Darshil\n"
     ]
    }
   ],
   "source": [
    "say_my_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d38dacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "def say_hello():\n",
    "    print('hello')\n",
    "\n",
    "#call the function \n",
    "\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b68128c",
   "metadata": {},
   "source": [
    "## Function Arguments\n",
    "***\n",
    "- Parameters may or may not have default values (in the example below, 'argn' has default value 3)\n",
    "- A function parameter can be passed either by position or by key/name\n",
    "- A function can accept a variable number of positional arguments (\\*args)\n",
    "- A function can accept a variable number of keyword arguments (\\*\\*kwargs)\n",
    "- Function parameters are passed by object reference\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417fb704",
   "metadata": {},
   "source": [
    "### Default Arguments / Keyword Arguments\n",
    "***\n",
    "- Default arguments are those arguments which can be changed but their value remains the same if not given. An example of the same is given below.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b837c74f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def double_the_number(num=1):\n",
    "    return num * 2\n",
    "\n",
    "print(double_the_number())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "03b868c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double_the_number(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82195777",
   "metadata": {},
   "source": [
    "## Positional Arguments\n",
    "***\n",
    "- Positional arguments are those which are not followed by an equal sign (=) and default value. In this we need to provide an argument while calling the function, else we get an error. Here is an example below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4731355f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def double_the_number(num):\n",
    "    return num*2\n",
    "\n",
    "print(double_the_number(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ddb8e158",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double_the_number(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ce742e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "def database_columns(*args):\n",
    "    for arg in args:\n",
    "        print(arg)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6c8790d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name\n",
      "age\n",
      "height\n",
      "asdas\n",
      "aasd\n"
     ]
    }
   ],
   "source": [
    "database_columns(\"name\", \"age\", \"height\",'asdas', 'aasd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "208f22d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def database_columns(**kwargs):\n",
    "    for value in kwargs.items():\n",
    "        print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "37cfcf31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('name', 'Darshil')\n",
      "('age', '25')\n"
     ]
    }
   ],
   "source": [
    "database_columns(name=\"Darshil\", age=\"25\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64a8fd1e",
   "metadata": {},
   "source": [
    "\n",
    "## Important Tip\n",
    "***\n",
    "- **Positional arguments** will always **precede** **Keyword arguments** while specifying both of them together in the same function. Below is an example of this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f436a594",
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(arg1, arg2, argn=3, *args, **kwargs):\n",
    "    print(\"This is a function.\")\n",
    "    # Function body here\n",
    "    return value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77205bb4",
   "metadata": {},
   "source": [
    "## `return` Values\n",
    "***\n",
    "\n",
    "A Return value is a value that is returned after performing a specific operation in a function. Some advantages and usecases of return values are as follows.\n",
    "- Unlike some other languages, Python allows returning multiple values \n",
    "- However, the multiple values is just a tuple of values\n",
    "- Because of this, the tuple can simply be 'opened' into multiple variables\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "81347fc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_my_name(name):\n",
    "    return name *3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "bb52059f",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = get_my_name(\"darshil\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "579eff32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'darshildarshildarshil'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcdd0dba",
   "metadata": {},
   "source": [
    "## Lambda\n",
    "***\n",
    "One of Pythons most useful (and for beginners, confusing) tools is the lambda expression. Lambda expressions allow us to create \"anonymous\" functions. This basically means we can quickly make ad-hoc functions without needing to properly define a function using def.\n",
    "\n",
    "Function objects returned by running lambda expressions work exactly the same as those created and assigned by defs. There is key difference that makes lambda useful in specialized roles:\n",
    "\n",
    "**Lambda's body is a single expression, not a block of statements.**\n",
    "* Python supports the creation of anonymous functions at runtime, using a construct called **`lambda`**\n",
    "* This approach is most commonly used when passing a simple function as an argument to another function.\n",
    "\n",
    "Now Lets slowly break down a lambda expression by deconstructing a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0e78ff15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square(num):\n",
    "    result = num**2\n",
    "    return result\n",
    "square(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8280fd0",
   "metadata": {},
   "source": [
    "We can actually write this in one line (although it would be bad style to do so)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a0440221",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(num): return num**2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "905726f5",
   "metadata": {},
   "source": [
    "This is the form of a function that a lambda expression intends to replicate. A lambda expression can then be written as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "dcf00652",
   "metadata": {},
   "outputs": [],
   "source": [
    "square_lambda = lambda num: num**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "91b97489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_lambda(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e51315ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_lambda = lambda num: num**2\n",
    "\n",
    "square_lambda(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e731fb0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_lambda = lambda a,b: a+b\n",
    "\n",
    "add_lambda(2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5086143b",
   "metadata": {},
   "source": [
    "# Object Oriented Programming\n",
    "***\n",
    "\n",
    "Object Oriented Programming (OOP) tends to be one of the major obstacles for beginners when they are first starting to learn Python.\n",
    "\n",
    "There are many,many tutorials and lessons covering OOP so feel free to Google search other lessons too. \n",
    "\n",
    "For this lesson we will construct our knowledge of OOP in Python by building on the following topics:\n",
    "\n",
    "* Objects\n",
    "* Using the *class* keyword\n",
    "* Creating class attributes\n",
    "* Creating methods in a class\n",
    "* Learning about Special Methods for classes\n",
    "\n",
    "What we will basically be doing is exploring how we could create an Object type like a list. We've already learned about how to create functions. So lets explore Objects in general:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20083a5b",
   "metadata": {},
   "source": [
    "## Objects\n",
    "***\n",
    "\n",
    "In Python, everything is an object. Remember from previous lectures we can use type() to check the type of object something is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "2fdf9063",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"my name is darshil\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d4b33e81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MY NAME IS DARSHIL'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "a8b60878",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1))\n",
    "print(type([]))\n",
    "print(type(()))\n",
    "print(type({}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6d3e576",
   "metadata": {},
   "source": [
    "## Class\n",
    "***\n",
    "All of the above, in the previous cell, are objects, so how can we create our own Object types? That is where the **class** keyword comes in.\n",
    "\n",
    "The user defined objects are created using the class keyword. The class is a blueprint that defines a nature of a future object. From classes we can construct instances. An instance is a specific object created from a particular class. \n",
    "\n",
    "Let see how we can use class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4aa1f1b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Sample'>\n"
     ]
    }
   ],
   "source": [
    "# Create a new object type called Sample\n",
    "class Sample():\n",
    "    pass\n",
    "\n",
    "# Instance of Sample\n",
    "x = Sample()\n",
    "\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aac959c",
   "metadata": {},
   "source": [
    "Note how x is now the reference to our new instance of a Sample class. In other words, we **instantiate** the Sample class.\n",
    "\n",
    "Inside of the class we currently just have pass. But we can define class attributes and methods.\n",
    "\n",
    "An **attribute** is a characteristic of an object.\n",
    "A **method** is an operation we can perform with the object.\n",
    "\n",
    "For example we can create a class called Dog. An attribute of a dog may be its breed or its name, while a method of a dog may be defined by a .bark() method which returns a sound.\n",
    "\n",
    "Let's get a better understanding of attributes through an example.\n",
    "\n",
    "## Attributes\n",
    "The syntax for creating an attribute is:\n",
    "    \n",
    "    self.attribute = something\n",
    "    \n",
    "There is a special method called:\n",
    "\n",
    "    __init__()\n",
    "\n",
    "which is used to initialize the attributes of an object. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a07e5de4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    def __init__(self,breed):\n",
    "        self.breed = breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "8a42f069",
   "metadata": {},
   "outputs": [],
   "source": [
    "sam = Dog(breed=\"Lab\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "a03dd2dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    def __init__(self,breed): #self shoud be the first argument always in the __init__ method.\n",
    "        self.breed = breed\n",
    "        \n",
    "sam = Dog(breed='Lab') # Instance 1. Copy one of the class Dog\n",
    "frank = Dog(breed='Huskie') # Instance 2. Copy two of the class Dog"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5539b2b3",
   "metadata": {},
   "source": [
    "Lets break down what we have above.The special method\n",
    "\n",
    "    __init__() \n",
    "\n",
    "is called automatically right after the object has been created:\n",
    "\n",
    "    def __init__(self, breed):\n",
    "Each attribute in a class definition begins with a reference to the instance object. It is by convention named self. The breed is the argument. The value is passed during the class instantiation.\n",
    "\n",
    "     self.breed = breed\n",
    "Now we have created two instances of the Dog class. With two breed types, we can then access these attributes like this:     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "64a60e1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lab'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam.breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "90caa091",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Huskie'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frank.breed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5d6d0b1",
   "metadata": {},
   "source": [
    "Note how we don't have any parenthesis after breed, this is because it is an attribute and doesn't take any arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb937e7",
   "metadata": {},
   "source": [
    "## Methods\n",
    "\n",
    "Methods are functions defined inside the body of a class. They are used to perform operations with the attributes of our objects. Methods are essential in encapsulation concept of the OOP paradigm. This is essential in dividing responsibilities in programming, especially in large applications.\n",
    "\n",
    "You can basically think of methods as functions acting on an Object that take the Object itself into account through its self argument.\n",
    "\n",
    "Let's see the explanation and go through an example of creating a Circle class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7405abef",
   "metadata": {},
   "source": [
    "\n",
    "### Explanation\n",
    "***\n",
    "- **`self`** is similar to the **`this`** pointer in other languages, except that (1) it needs to be explicitly passed as the first parameter of the instance method, and (2) is not a reserved keyword\n",
    "\n",
    "- The **`__init__`** method is an initializer (_not_ constructor) and called on instantiation\n",
    "\n",
    "- The **`__str__`** method is equivalent to toString()\n",
    "\n",
    "- The **`__repr__`** method defines how the object is represented on console"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5061f765",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle(object):\n",
    "    pi = 3.14\n",
    "    \n",
    "    def __init__(self, radius=1):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def area(self):\n",
    "        return self.radius * self.radius * Circle.pi\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a8cbc670",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Circle(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "ce59cee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.24"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "aee3c86c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Radius is:  2\n",
      "Area is:  12.56\n"
     ]
    }
   ],
   "source": [
    "class Circle(object):\n",
    "    pi = 3.14 #This is a Class-Object attribute.\n",
    "              #It remains same for all the methods within the class\n",
    "\n",
    "    # Circle get instantiated with a radius (default is 1)\n",
    "    def __init__(self, radius=1):\n",
    "        self.radius = radius \n",
    "\n",
    "    # Area method calculates the area. Note the use of self.\n",
    "    def area(self):\n",
    "        return self.radius * self.radius * Circle.pi\n",
    "\n",
    "    # Method for resetting Radius\n",
    "    def setRadius(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    # Method for getting radius (Same as just calling .radius)\n",
    "    def getRadius(self):\n",
    "        return self.radius\n",
    "\n",
    "\n",
    "c = Circle()\n",
    "\n",
    "c.setRadius(2)\n",
    "print('Radius is: ',c.getRadius())\n",
    "print('Area is: ',c.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "83a4ae40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Circle()\n",
    "c.getRadius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "c4c06529",
   "metadata": {},
   "outputs": [],
   "source": [
    "c.setRadius(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "8e31612f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.getRadius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "af376638",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78.5"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74cc8403",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Instance vs Class vs Static Methods\n",
    "***\n",
    "- Instance methods have access to the **instance** of the class\n",
    "- Class methods have access to the **class** (classes are also objects in Python), but not instances. This is similar to the static methods in Java/C#\n",
    "- Static methods have no access to either instances or classes. They are more like plain functions, just bounded with the class for scoping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5837dd48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance method called <__main__.MyClass object at 0x105eb4fd0>\n",
      "class method called <class '__main__.MyClass'>\n",
      "static method called\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def instance_method(self):\n",
    "        print('instance method called', self)\n",
    "\n",
    "    @classmethod\n",
    "    def class_method(cls):\n",
    "        print('class method called', cls)\n",
    "\n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        print('static method called')\n",
    "\n",
    "obj = MyClass()\n",
    "\n",
    "obj.instance_method()\n",
    "MyClass.class_method()\n",
    "MyClass.static_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "bf40d0e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    # class variables\n",
    "    school_name = 'ABC School'\n",
    "\n",
    "    # constructor\n",
    "    def __init__(self, name, age):\n",
    "        # instance variables\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    # instance variables\n",
    "    def show(self):\n",
    "        print(self.name, self.age, Student.school_name)\n",
    "\n",
    "    @classmethod\n",
    "    def change_School(cls, name):\n",
    "        cls.school_name = name\n",
    "\n",
    "    @staticmethod\n",
    "    def find_notes(subject_name):\n",
    "        return ['chapter 1', 'chapter 2', 'chapter 3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "6d371ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "Student.change_School(\"XYZ School\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ed9837c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Darshil 25 XYZ School\n"
     ]
    }
   ],
   "source": [
    "darshil.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "34b688e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "darshil = Student(\"Darshil\", 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "5c2f66da",
   "metadata": {},
   "outputs": [],
   "source": [
    "rahul = Student(\"Rahul\", 24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "00c3c84a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Darshil'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "darshil.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e3fd029b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC School'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "darshil.school_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "392ef6b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['chapter 1', 'chapter 2', 'chapter 3']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "darshil.find_notes('math')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "9889c9cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC School'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rahul.school_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "689287cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jessa 12 ABC School\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['chapter 1', 'chapter 2', 'chapter 3']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create object\n",
    "jessa = Student('Jessa', 12)\n",
    "# call instance method\n",
    "jessa.show()\n",
    "\n",
    "# call class method using the class\n",
    "Student.change_School('XYZ School')\n",
    "# call class method using the object\n",
    "jessa.change_School('PQR School')\n",
    "\n",
    "# call static method using the class\n",
    "Student.find_notes('Math')\n",
    "# call class method using the object\n",
    "jessa.find_notes('Math')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d60c0930",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "28532b21",
   "metadata": {},
   "source": [
    "\n",
    "### Mini Challenge - 1\n",
    "***\n",
    "Can you write a function square_root having default value of input a=9 and find the square-root of the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d47438df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8d945139",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Mini Challenge - 2\n",
    "***\n",
    "Can you write a function function_tuple that takes in two numbers a and b and returns the sum as well as the product of these numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a8c33d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "774a3a1d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}