Day15 - OOP in Python(part-2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **OOP in Python Part - 2** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is Function and method in Python??\n",
    "In Python, functions and methods are both used to define blocks of reusable code, but they have some key differences:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Function:\n",
    "\n",
    "* A function is a block of organized, reusable code that performs a specific task.\n",
    "* Functions in Python are defined using the def keyword, followed by a function name, a set of parameters in parentheses, a colon, and the function's code block.\n",
    "* Functions can take input parameters (arguments) and return a value using the return statement. However, not all functions need to return a value.\n",
    "* Functions can be called by their name, and they are usually defined at the module level (i.e., not inside a class or another function)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Method:\n",
    "* A method is similar to a function, but it is associated with an object or a class.\n",
    "* Methods are defined within a class and are used to define the behaviors or actions that objects of that class can perform.\n",
    "* Methods are called on instances of a class and typically operate on the data (attributes) of the instance.\n",
    "* The first parameter of a method is usually named 'self', which refers to the instance on which the method is called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary, functions are standalone blocks of code, while methods are functions defined within a class and are associated with instances of that class. Methods often work with the data (attributes) of the instance, whereas functions can be called independently of any specific object or class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# _init_\n",
    "class Subject:\n",
    " \n",
    "    def __init__(self, attr1, attr2):\n",
    "        self.attr1 = attr1\n",
    "        self.attr2 = attr2\n",
    " \n",
    " \n",
    "obj = Subject('Maths', 'Science')\n",
    "print(obj.attr1) \n",
    "print(obj.attr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magic Methods:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, \"magic methods,\" also known as \"dunder methods\" (short for \"double underscore methods\"), are special methods that have double underscores at the beginning and end of their names, such as _ _init_ _ , _ _str_ _ , _ _add_ _ , etc. These methods are also sometimes referred to as \"special methods\" or \"dunder methods\" because of their naming convention.\n",
    "\n",
    "Magic methods are used to define how objects of a class behave in various situations and allow you to customize the behavior of your custom classes. They are automatically invoked by the Python interpreter in response to specific operations or built-in functions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **1. _ _ init _ _** :\n",
    "\n",
    "* The _ _init_ _ method in Python is like a special function that gets called when you create a new object from a class. \n",
    "* It's often referred to as the \"constructor\" because it helps you set up, or \"initialize,\" the initial state of an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameterized constructor -> It wants input while form an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "person1 = Person(\"Alice\", 30)\n",
    "person2 = Person(\"Bob\", 25)\n",
    "# person1 will have name set to \"Alice\" and age set to 30, while person2 will have name set to \"Bob\" and age set to 25."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x00000220D6DEAD90>\n"
     ]
    }
   ],
   "source": [
    "print(person1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* when we print person 1 then python don't know how to show Alice with age 30 ..python show only Memory location where it store \n",
    "* so for we call _ _ str _ _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **2. _ _ str _ _**:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The __str__ method in Python is a special method (often called a \"magic method\" or \"dunder method\") that you can define in your custom classes to provide a **human-readable string** representation of objects created from that class. \n",
    "* This method is automatically called when you use the str() function or the print() function on an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice (30 years old)\n",
      "Alice (30 years old)\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} ({self.age} years old)\"\n",
    "\n",
    "# Create a Person object\n",
    "person = Person(\"Alice\", 30)\n",
    "\n",
    "# When you use str() or print(), Python calls __str__ automatically\n",
    "print(str(person))  # Output: \"Alice (30 years old)\"\n",
    "print(person)        # Output: \"Alice (30 years old)\"\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.18"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}