notebooks/Python - OOPs - Duck Typing.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python OOPs & Duck Typing\n",
    "---\n",
    "\n",
    "A minimal guide to understand Python Object Oriented programming.\n",
    "\n",
    "This blog is a fresh new approach to learn Python Concepts to help solve a real world problem. You will find this blog helpful in case you are wondering how Object oriented programming helps and implemented in data science projects.\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes provide a means of bundling data and functionality together.\n",
    "It's primary purpose is to define data structures, state and provide methods to update data.\n",
    "\n",
    "Creating a new class creates a new type of object, allowing new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Names and Objects\n",
    "\n",
    "In Python, multiple names can refer to the same object (aliasing), which is generally safe for immutable types like numbers and strings. However, aliasing can affect the semantics of code involving mutable objects like lists and dictionaries, allowing for efficient object passing and shared modifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Scopes and Namespaces\n",
    "\n",
    "In Python, scopes are defined by the context in which a name is created, while namespaces are the actual containers for names.\n",
    "\n",
    "There are four nested scopes in Python: local, enclosing, global, and built-in. \n",
    "\n",
    "Local scope refers to variables defined within a function, enclosing scope to variables in outer functions, global scope to variables declared as global in a function, and built-in scope to Python's built-in names. \n",
    "\n",
    "Namespaces are created for each scope, and the LEGB (Local, Enclosing, Global, Built-in) rule is used to search for names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOPs in Python\n",
    "\n",
    "Here's an example of Object-Oriented Programming (OOP) in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buddy says woof!\n",
      "Buddy is sleeping now.\n"
     ]
    }
   ],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, breed):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "\n",
    "    def bark(self):\n",
    "        return f\"{self.name} says woof!\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is sleeping now.\"\n",
    "\n",
    "\n",
    "my_dog = Dog(\"Buddy\", \"Golden Retriever\")\n",
    "print(my_dog.bark())  # Output: Buddy says woof!\n",
    "print(my_dog.sleep())  # Output: Buddy is sleeping now.\n",
    "\n",
    "# In this example, `Dog` is a class that represents a dog with name and breed attributes. The `bark()` and `sleep()` methods define the behavior of a dog. `my_dog` is an object (or instance) of the class `Dog`, and we can call its methods to see its behavior. This is the essence of object-oriented programming in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, `Dog` is a class that represents a dog with name and breed attributes. \n",
    "\n",
    "The `bark()` and `sleep()` methods define the behavior of a dog. \n",
    "\n",
    "`my_dog` is an object (or instance) of the class `Dog`, and we can call its methods to see its behavior. This is the essence of object-oriented programming in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Duck Typing\n",
    "\n",
    "Duck typing is a programming concept that refers to the idea that an object's suitability for use is determined by the presence of certain methods and attributes, rather than by its inheritance from a specific class hierarchy.\n",
    "\n",
    "The term \"duck typing\" comes from the phrase \"If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.\"\n",
    "\n",
    "Python is a dynamically typed language that implements duck typing by checking for the presence of methods and attributes at runtime. \n",
    "\n",
    "This allows Python to be flexible and dynamic, as objects can be used in different contexts based on their behavior, rather than their class hierarchy.\n",
    "\n",
    "Here's an example of duck typing in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The duck is flying.\n",
      "This bird cannot fly.\n"
     ]
    }
   ],
   "source": [
    "def fly(bird):\n",
    "    if hasattr(bird, 'fly'):\n",
    "        print(bird.fly())\n",
    "    else:\n",
    "        print(\"This bird cannot fly.\")\n",
    "\n",
    "class Duck:\n",
    "    def fly(self):\n",
    "        return \"The duck is flying.\"\n",
    "\n",
    "class Penguin:\n",
    "    pass\n",
    "\n",
    "my_duck = Duck()\n",
    "my_penguin = Penguin()\n",
    "\n",
    "fly(my_duck)  # Output: The duck is flying.\n",
    "fly(my_penguin)  # Output: This bird cannot fly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, \n",
    "\n",
    "the `fly()` function takes an object as an argument and checks if it has a `fly()` method. \n",
    "\n",
    "If it does, the function calls the method and prints the result. \n",
    "\n",
    "If not, it prints a message indicating that the bird cannot fly. \n",
    "\n",
    "The `Duck` class has a `fly()` method, while the `Penguin` class does not. \n",
    "\n",
    "The `fly()` function works with both `Duck` and `Penguin` objects, demonstrating duck typing in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: John\n",
      "Age: 30\n",
      "Address: 123 Main St.\n"
     ]
    }
   ],
   "source": [
    "def print_info(obj):\n",
    "    if hasattr(obj, 'name'):\n",
    "        print(f\"Name: {obj.name}\")\n",
    "    if hasattr(obj, 'age'):\n",
    "        print(f\"Age: {obj.age}\")\n",
    "    if hasattr(obj, 'get_address'):\n",
    "        print(f\"Address: {obj.get_address()}\")\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def get_address(self):\n",
    "        return \"123 Main St.\"\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, make, model):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "\n",
    "my_person = Person(\"John\", 30)\n",
    "my_car = Car(\"Toyota\", \"Camry\")\n",
    "\n",
    "print_info(my_person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quack!\n",
      "I'm Quacking Like a Duck!\n"
     ]
    }
   ],
   "source": [
    "# here is another example of duck typing\n",
    "class Duck:\n",
    "    def quack(self):\n",
    "        return 'Quack!'\n",
    "\t\n",
    "class Person:\n",
    "    def quack(self):\n",
    "       return \"I'm Quacking Like a Duck!\"\n",
    "\t\n",
    "def in_the_forest(malard):\n",
    "\t    print(malard.quack())\n",
    "\t\n",
    "donald = Duck()\n",
    "john = Person()\n",
    "\t\n",
    "in_the_forest(donald)\n",
    "in_the_forest(john)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the `in_the_forest` function takes an object and calls its `quack` method without checking the type of the object, showcasing duck typing in Python.\n",
    "\n",
    "The function works as long as the object passed in has a `quack` method, emphasizing behavior over type."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "RPA",
   "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.12.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}