Added dataclasses and typing examples

Author: mohd-faizy

09_New_in_Python/09_dataclasses.ipynb

@@ -0,0 +1,393 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## **`dataclasses`**"
+      ],
+      "metadata": {
+        "id": "XE_IcA4YSc-F"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from dataclasses import dataclass\n",
+        "\n",
+        "@dataclass\n",
+        "class Person:\n",
+        "    name: str\n",
+        "    age: int\n",
+        "    city: str\n",
+        "\n",
+        "# Creating an instance of the Person dataclass\n",
+        "person = Person(name=\"Alice\", age=30, city=\"New York\")\n",
+        "\n",
+        "# Accessing the fields\n",
+        "print(person.name)  # Output: Alice\n",
+        "print(person.age)   # Output: 30\n",
+        "print(person.city)  # Output: New York"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9KpkWmtTCmbd",
+        "outputId": "07ed2ee3-e954-40f9-f2bf-425ad55b67a7"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Alice\n",
+            "30\n",
+            "New York\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from dataclasses import dataclass\n",
+        "\n",
+        "@dataclass\n",
+        "class Address:\n",
+        "    street: str\n",
+        "    city: str\n",
+        "    zipcode: str\n",
+        "\n",
+        "@dataclass\n",
+        "class Person:\n",
+        "    name: str\n",
+        "    age: int\n",
+        "    address: Address\n",
+        "\n",
+        "# Creating an instance of the Address class\n",
+        "address1 = Address(street=\"123 Main St\", city=\"New York\", zipcode=\"10001\")\n",
+        "\n",
+        "# Creating an instance of the Person class with the Address instance\n",
+        "person1 = Person(name=\"Alice\", age=30, address=address1)\n",
+        "\n",
+        "# Accessing the nested attributes\n",
+        "print(person1.address.city)  # Output: New York"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "N1V7ZtvFlsGs",
+        "outputId": "5aaa41b0-82e4-4037-f80f-3f4f8c7584c5"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "New York\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from dataclasses import dataclass, field\n",
+        "\n",
+        "@dataclass\n",
+        "class Product:\n",
+        "    name: str\n",
+        "    price: float\n",
+        "    in_stock: bool = True\n",
+        "    tags: list = field(default_factory=list)\n",
+        "\n",
+        "# Creating an instance of the Product class\n",
+        "product1 = Product(name=\"Laptop\", price=999.99)\n",
+        "\n",
+        "# Accessing the attributes\n",
+        "print(product1.name)      # Output: Laptop\n",
+        "print(product1.in_stock)  # Output: True\n",
+        "print(product1.tags)      # Output: []\n",
+        "\n",
+        "# Adding a tag to the product\n",
+        "product1.tags.append(\"Electronics\")\n",
+        "print(product1.tags)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "z1312whblx0i",
+        "outputId": "700cd896-488a-4627-d111-58d2813ab8dc"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Laptop\n",
+            "True\n",
+            "[]\n",
+            "['Electronics']\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "In this example, the `Person` class is defined as a `dataclass` with three fields: `name`, `age`, and `city`. The `dataclass` decorator automatically generates special methods like `__init__()`and `__repr__()` for the class, making it easier to work with.\n",
+        "\n",
+        "- The `__init__` method in Python is a **special method** used to initialize the attributes of an object when it is created. It’s often referred to as a constructor. When you create a new instance of a class, Python automatically calls the `__init__` method to set up the initial state of the object.\n",
+        "\n",
+        "- The `__repr__` method in Python is a **special method** used to define the string representation of an object."
+      ],
+      "metadata": {
+        "id": "huCxk1dfCuey"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class Person:\n",
+        "    def __init__(self, name: str, age: int, city: str):\n",
+        "        self.name = name\n",
+        "        self.age = age\n",
+        "        self.city = city\n",
+        "\n",
+        "    def __repr__(self):\n",
+        "        return f\"Person(name={self.name}, age={self.age}, city={self.city})\"\n",
+        "\n",
+        "# Creating an instance of the Person class\n",
+        "person = Person(name=\"Alice\", age=30, city=\"New York\")\n",
+        "\n",
+        "# Accessing the fields\n",
+        "print(person.name)  # Output: Alice\n",
+        "print(person.age)   # Output: 30\n",
+        "print(person.city)  # Output: New York"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GQngSHM6Dl8M",
+        "outputId": "4605dca3-1aa3-4bed-87f6-74ae7d453501"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Alice\n",
+            "30\n",
+            "New York\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "If you don’t use `dataclasses`, you would typically define a class with an `__init__` method to initialize the attributes.\n",
+        "\n",
+        "\n",
+        ">The `@dataclass` decorator in Python is used to automatically generate special methods for classes, such as `__init__()`, `__repr__()`, `__eq__()`, and others. **This helps reduce boilerplate code and makes it easier to create classes that are primarily used to store data.**"
+      ],
+      "metadata": {
+        "id": "nrEN6XXfDrmu"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## **`typing`**\n",
+        "\n",
+        "\n",
+        "The `from typing import List` statement in Python is used to import the `List` type hint from the `typing` module. This allows you to specify the type of elements that a list should contain, which can be very helpful for code readability and for tools like type checkers and IDEs to provide better support and error checking.\n",
+        "\n",
+        "Here’s an example of how it’s used:"
+      ],
+      "metadata": {
+        "id": "rqWqyDyvTzpB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import List\n",
+        "\n",
+        "def sum_of_elements(elements: List[int]) -> int:\n",
+        "    return sum(elements)\n",
+        "\n",
+        "numbers = [1, 2, 3, 4, 5]\n",
+        "print(sum_of_elements(numbers))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BFLobiRkT1-y",
+        "outputId": "ba1d8255-440b-4156-ea80-d909490fd764"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "15\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Dict\n",
+        "\n",
+        "def get_student_grades() -> Dict[str, int]:\n",
+        "    return {\"Alice\": 90, \"Bob\": 85, \"Charlie\": 92}\n",
+        "\n",
+        "grades = get_student_grades()\n",
+        "print(grades)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SSzIFknblN-6",
+        "outputId": "ebe04324-e55a-4a25-96ed-8061aafb3120"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'Alice': 90, 'Bob': 85, 'Charlie': 92}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Union\n",
+        "\n",
+        "def process_data(data: Union[int, str]) -> str:\n",
+        "    if isinstance(data, int):\n",
+        "        return f\"Processed number: {data}\"\n",
+        "    elif isinstance(data, str):\n",
+        "        return f\"Processed string: {data}\"\n",
+        "\n",
+        "print(process_data(10))  # Output: Processed number: 10\n",
+        "print(process_data(\"hello\"))  # Output: Processed string: hello\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "nq_kZmBWlZc6",
+        "outputId": "37816c45-9070-497f-eb1d-ecaaa3858170"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Processed number: 10\n",
+            "Processed string: hello\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Optional\n",
+        "\n",
+        "def find_user(user_id: int) -> Optional[str]:\n",
+        "    users = {1: \"Alice\", 2: \"Bob\", 3: \"Charlie\"}\n",
+        "    return users.get(user_id)\n",
+        "\n",
+        "print(find_user(1))  # Output: Alice\n",
+        "print(find_user(4))  # Output: None\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0CfFra8rlaxr",
+        "outputId": "c196b561-96dd-4a49-a4f5-3a8e30609135"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Alice\n",
+            "None\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Callable\n",
+        "\n",
+        "def execute_function(func: Callable[[int, int], int], a: int, b: int) -> int:\n",
+        "    return func(a, b)\n",
+        "\n",
+        "def add(x: int, y: int) -> int:\n",
+        "    return x + y\n",
+        "\n",
+        "def multiply(x: int, y: int) -> int:\n",
+        "    return x * y\n",
+        "\n",
+        "print(execute_function(add, 2, 3))  # Output: 5\n",
+        "print(execute_function(multiply, 2, 3))  # Output: 6"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TzSljUHPlb6h",
+        "outputId": "b1a35987-7a64-4081-e74f-07aebad6110e"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "5\n",
+            "6\n"
+          ]
+        }
+      ]
+    }
+  ]
+}