Seesion_1(C201087).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMQgVshQ3brz2PhxMwgLE2j",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ZiaulHoqueKhasru/FieldWork/blob/main/Seesion_1(C201087).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#1. Working on Variables"
      ],
      "metadata": {
        "id": "jM4F5DInZ8_T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "iN-gEuB7VcjA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BTzSbHVNVYOJ",
        "outputId": "9fc78119-d8f6-4e71-ea02-235ec3ddfb78"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is: Md. Ziaul Hoque and age is:25\n"
          ]
        }
      ],
      "source": [
        "# Assignment 1: Create two variables, one holding a number and the other holding your name. Then print both.\n",
        "\n",
        "name = \"Md. Ziaul Hoque\"\n",
        "age = 25\n",
        "print(f\"My name is: {name} and age is: {age}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "wP9QsrcgWQUb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create variables of different types and use the type() function to check their types.\n",
        "\n",
        "name = \"Khasru\"\n",
        "age = 25\n",
        "sallary = 30000.500\n",
        "gander = True\n",
        "print(type(name))\n",
        "print(type(age))\n",
        "print(type(sallary))\n",
        "print(type(gander))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4qfX1nrsWZKV",
        "outputId": "a85a7d65-f6ea-4ec3-e28c-3aeabf45a816"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-3"
      ],
      "metadata": {
        "id": "RadCUbzeYMPJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#good_name = \"John\"\n",
        "#_bad_name = 23\n",
        "# 2bad = 42  # This will raise a SyntaxError because variable names cannot begin with a number.\n",
        "\n",
        "# Assignment 3: Fix the bad variable name above and create three more variables with good naming practices.\n",
        "\n",
        "\n",
        "bad = 42 # fixed\n",
        "#similar are\n",
        "native_name = \"khasru\"\n",
        "home_address = \"chandraghona\"\n",
        "print(f\"fixed variable is {bad}\")\n",
        "print(f\"native name is {native_name}\")\n",
        "print(f\"home address is {home_address}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ocOeGW-EYOWe",
        "outputId": "8a3586de-8571-4b7e-f416-f8a09c42cc11"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fixed variable is 42\n",
            "native name is khasru\n",
            "home address is chandraghona\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-4"
      ],
      "metadata": {
        "id": "h8pHQwIKY9Xc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 4: Create a variable, assign it a value of one type, then reassign it to a different type and print both.\n",
        "var = \"first_assign\"\n",
        "print(var)\n",
        "var = 2\n",
        "print(var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HXqiJj-7ZGHL",
        "outputId": "b57c0bf3-f3b0-4bfa-f74e-385d70b91bef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "first_assign\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#2. Working on List_tuples"
      ],
      "metadata": {
        "id": "a6K_X75daM8S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "LmZ1huyXaTP6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###practice"
      ],
      "metadata": {
        "id": "VQfYBE3XbqAw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "simple_list = [8, 2, 9, 4, 5]\n",
        "mixed_list = [1, \"Hello\", 3.14, True]\n",
        "temp_list = []  # Empty list\n",
        "empty_list = list()\n",
        "\n",
        "# 2D List (List of Lists)\n",
        "matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "\n",
        "# Accessing Elements\n",
        "# You can access elements by their index, which starts at 0.\n",
        "first_element = simple_list[2]  # Outputs 9\n",
        "second_row_first_col = matrix[1][2]  # Outputs 4\n",
        "list_range = simple_list[1:4] # Outputs [2, 9, 4]\n",
        "# list_stepping = simple_list[1:7:2]\n",
        "list_stepping = simple_list[::2]\n",
        "print(first_element)\n",
        "print(second_row_first_col)\n",
        "print(\"List Stepping: \", list_stepping)\n",
        "print(\"List Range: \", list_range)\n",
        "\n",
        "# List Operations\n",
        "# Adding elements\n",
        "print(\"Before Apprend Operation: \", simple_list)\n",
        "simple_list.append(6)  # Adds 6 to the end\n",
        "print(\"After Append operation: \", simple_list)\n",
        "simple_list.insert(2, 6)  # Inserts 0 at the beginning\n",
        "print(\"After Insert operation: \", simple_list)\n",
        "\n",
        "# Removing elements\n",
        "simple_list.remove(6)  # Removes the first occurrence of 6\n",
        "print(\"After Remove operation: \", simple_list)\n",
        "popped_element = simple_list.pop()  # Removes and returns the last element\n",
        "print(\"Popped element:\", popped_element)\n",
        "print(\"After Pop operation: \", simple_list)\n",
        "\n",
        "# List Methods\n",
        "# Join lists\n",
        "combined_list = simple_list + mixed_list\n",
        "print(\"Combined List: \", combined_list)\n",
        "\n",
        "# Sort lists\n",
        "simple_list.sort()  # Sorts the list in place\n",
        "print(\"Sorted List: \", simple_list)\n",
        "\n",
        "# Copy a list\n",
        "duplicate_list = simple_list\n",
        "\n",
        "duplicate_list.append(7)\n",
        "print(\"simple_list id\", id(simple_list), \"duplicate_list id: \", id(duplicate_list))\n",
        "print(\"Duplicate List: \", duplicate_list)\n",
        "print(\"Simple List: \", simple_list)\n",
        "\n",
        "list_copy = simple_list.copy()\n",
        "list_copy.append(8)\n",
        "print(\"simple_list id\", id(simple_list), \"list_copy id: \", id(list_copy))\n",
        "print(\"List Copy: \", list_copy)\n",
        "print(\"Simple List: \", simple_list)\n",
        "\n",
        "# Get the number of elements\n",
        "list_length = len(simple_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bboWbYMEaQ37",
        "outputId": "5364fdf1-8734-4233-ff2b-6dd598589c69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n",
            "6\n",
            "List Stepping:  [8, 9, 5]\n",
            "List Range:  [2, 9, 4]\n",
            "Before Apprend Operation:  [8, 2, 9, 4, 5]\n",
            "After Append operation:  [8, 2, 9, 4, 5, 6]\n",
            "After Insert operation:  [8, 2, 6, 9, 4, 5, 6]\n",
            "After Remove operation:  [8, 2, 9, 4, 5, 6]\n",
            "Popped element: 6\n",
            "After Pop operation:  [8, 2, 9, 4, 5]\n",
            "Combined List:  [8, 2, 9, 4, 5, 1, 'Hello', 3.14, True]\n",
            "Sorted List:  [2, 4, 5, 8, 9]\n",
            "simple_list id 140420302832768 duplicate_list id:  140420302832768\n",
            "Duplicate List:  [2, 4, 5, 8, 9, 7]\n",
            "Simple List:  [2, 4, 5, 8, 9, 7]\n",
            "simple_list id 140420302832768 list_copy id:  140420302847488\n",
            "List Copy:  [2, 4, 5, 8, 9, 7, 8]\n",
            "Simple List:  [2, 4, 5, 8, 9, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Task"
      ],
      "metadata": {
        "id": "uu8KCzukbuQ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Create a 2D list representing a 3x3 matrix and perform operations like accessing, modifying, and iterating through it.\n",
        "\n",
        "\n",
        "matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "print(matrix)\n",
        "print(f\"2nd row 2nd colunm value is: {matrix[1][1]}\")\n",
        "matrix[1][1]=-10\n",
        "print(matrix)\n",
        "for i in matrix:\n",
        "  for j in i:\n",
        "    print(j,end=\" \")\n",
        "  print()\n",
        "\n",
        "matrix.insert(1,[10,11,12])\n",
        "print(\"new matrix after inserting row in 2nd positon\")\n",
        "for i in matrix:\n",
        "  for j in i:\n",
        "    print(j,end=\" \")\n",
        "  print()\n",
        "for i in range(len(matrix)):\n",
        "  matrix[i].insert(1,i)\n",
        "print(\"new matrix after inserting colunm in 2nd positon\")\n",
        "for i in matrix:\n",
        "  for j in i:\n",
        "    print(j,end=\" \")\n",
        "  print()\n",
        "\n",
        "matrix2=matrix.copy()\n",
        "matrix2.append([0,0,0])\n",
        "print(\"matrix2\")\n",
        "for i in matrix2:\n",
        "  for j in i:\n",
        "    print(j,end=\" \")\n",
        "  print()\n",
        "print(\"matrix\")\n",
        "for i in matrix:\n",
        "  for j in i:\n",
        "    print(j,end=\" \")\n",
        "  print()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O4RsuNGJbvwR",
        "outputId": "2b776102-7cf6-4645-8077-db75c748c5bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
            "2nd row 2nd colunm value is: 5\n",
            "[[1, 2, 3], [4, -10, 6], [7, 8, 9]]\n",
            "1 2 3 \n",
            "4 -10 6 \n",
            "7 8 9 \n",
            "new matrix after inserting row in 2nd positon\n",
            "1 2 3 \n",
            "10 11 12 \n",
            "4 -10 6 \n",
            "7 8 9 \n",
            "new matrix after inserting colunm in 2nd positon\n",
            "1 0 2 3 \n",
            "10 1 11 12 \n",
            "4 2 -10 6 \n",
            "7 3 8 9 \n",
            "matrix2\n",
            "1 0 2 3 \n",
            "10 1 11 12 \n",
            "4 2 -10 6 \n",
            "7 3 8 9 \n",
            "0 0 0 \n",
            "matrix\n",
            "1 0 2 3 \n",
            "10 1 11 12 \n",
            "4 2 -10 6 \n",
            "7 3 8 9 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "iuIcnlAZOtRX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "k2enzJdpOypP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        " Assignment 2: Create a tuple with mixed data types and demonstrate its potential use cases in data structures like dictionaries.\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "wYXYH5GLQ56d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mixed_tuple = (101, \"zia\", 29, 5.9, [\"Python\", \"Machine Learning\"])\n"
      ],
      "metadata": {
        "id": "ATbbw8ByO1BP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the Tuple in a Dictionary"
      ],
      "metadata": {
        "id": "XIAYi1hXRufs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example use case: Employee database\n",
        "employee_database = {\n",
        "    \"emp101\": mixed_tuple,\n",
        "    \"emp102\": (102, \"zia\", 34, 6.1, [\"Java\", \"Data Science\"]),\n",
        "    \"emp103\": (103, \"amit\", 27, 5.8, [\"C++\", \"Cybersecurity\"]),\n",
        "}\n",
        "\n",
        "# Accessing the tuple data\n",
        "print(\"Details of emp101:\", employee_database[\"emp101\"])\n",
        "\n",
        "# Extracting individual elements from the tuple\n",
        "emp_name = employee_database[\"emp101\"][1]\n",
        "emp_skills = employee_database[\"emp101\"][4]\n",
        "print(\"Name of emp101:\", emp_name)\n",
        "print(\"Skills of emp101:\", emp_skills)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NCZ9FsljRAbS",
        "outputId": "8e1e17c2-9868-4773-8b85-cd56666352f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Details of emp101: (101, 'zia', 29, 5.9, ['Python', 'Machine Learning'])\n",
            "Name of emp101: zia\n",
            "Skills of emp101: ['Python', 'Machine Learning']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the Tuple as a Key in a Dictionary"
      ],
      "metadata": {
        "id": "59_jUqhTRzz5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example use case: Combination of attributes as a key\n",
        "sales_data = {\n",
        "    (101, \"zia\", 2024): 50000,  # Key: (employee ID, name, year), Value: sales amount\n",
        "    (102, \"amit\", 2024): 60000,\n",
        "    (103, \"nib\", 2024): 55000,\n",
        "}\n",
        "\n",
        "# Accessing sales data for a specific employee in a specific year\n",
        "key = (101, \"zia\", 2024)\n",
        "sales_amount = sales_data.get(key, \"No data available\")\n",
        "print(f\"Sales amount for {key}: {sales_amount}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IOTI_QyARFe9",
        "outputId": "5698d2d5-36a8-4e41-9e00-09d21a016fa3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sales amount for (101, 'zia', 2024): 50000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-3"
      ],
      "metadata": {
        "id": "CnuwGUG4Ey8v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 3: Create a list of tuples, where each tuple contains a student's name and their grade. Sort this list by grades.\n",
        "students=[(\"Zia\",3.86),(\"Amit\",3.6),(\"Nibras\",3.7)]\n",
        "sorted_students = sorted(students, key=lambda x: x[1], reverse=True)\n",
        "print(sorted_students)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tIsESysAIlLn",
        "outputId": "ef7d5dcd-5d35-45f0-ef89-1bc9e48b40d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Zia', 3.86), ('Nibras', 3.7), ('Amit', 3.6)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3.Dictionary"
      ],
      "metadata": {
        "id": "lz0BL4d331EM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Dr1pybglZgAM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Practice\n"
      ],
      "metadata": {
        "id": "buE63Onc35hL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Advanced Python: Dictionaries\n",
        "\n",
        "\n",
        "# Section 1: Dictionary Basics\n",
        "# ----------------------------\n",
        "# Dictionaries in Python are unordered collections that store data in key-value pairs.\n",
        "\n",
        "# Example 1: Creating and Using Dictionaries\n",
        "simple_dict = {'name': 'John', 'age': 30, 'city': 'New York'}\n",
        "print(simple_dict[\"city\"])\n",
        "# print(simple_dict['address'])  # Accessing value by key\n",
        "print(simple_dict.get('age', 0))  # Accessing value by key\n",
        "print(simple_dict.get('address', 'Texas'))  # Accessing value by key\n",
        "\n",
        "\n",
        "# Updating dictionary\n",
        "simple_dict['age'] = 31  # Updates the age\n",
        "simple_dict['country'] = 'USA'  # Adds a new key-value pair\n",
        "# print(\"Updated Dictionary: \", simple_dict)\n",
        "\n",
        "# Dictionary Methods\n",
        "# keys(), values(), items()\n",
        "print(simple_dict.keys())  # Prints all keys\n",
        "print(simple_dict.values())  # Prints all values\n",
        "print(simple_dict.items())  # Prints all key-value pairs as tuples\n",
        "\n",
        "# get()\n",
        "print(simple_dict.get('name'))  # Returns 'John'\n",
        "\n",
        "# pop()\n",
        "removed_value = simple_dict.pop('country')  # Removes 'country' key and returns its value\n",
        "print(\"Removed Value:\", removed_value)\n",
        "print(\"Dictionary after pop(): \", simple_dict)\n",
        "\n",
        "# popitem()\n",
        "last_item = simple_dict.popitem()  # Removes and returns the last inserted key-value pair\n",
        "print(\"Last Item:\", last_item)\n",
        "print(\"Dictionary after popitem(): \", simple_dict)\n",
        "\n",
        "# update()\n",
        "simple_dict.update({'age': 32, 'email': 'john@example.com'})  # Updates the dictionary\n",
        "print(\"Dictionary after update(): \", simple_dict)\n",
        "\n",
        "# clear()\n",
        "# simple_dict.clear()  # Empties the dictionary\n",
        "# print(\"Dictionary after clear(): \", simple_dict)\n",
        "\n",
        "# copy()\n",
        "dict_copy = simple_dict.copy()  # Creates a shallow copy of the dictionary\n",
        "print(\"Dictionary Copy: \", dict_copy)\n",
        "\n",
        "# Assignment 1: Create a dictionary representing a student with keys like 'name', 'roll_number', 'grades' (a list of subjects and marks).\n",
        "# Perform various operations like adding, removing, and modifying elements.\n",
        "# Write your code below:\n",
        "\n",
        "\n",
        "# Section 2: Integrating Dictionaries with Lists and Tuples\n",
        "# ---------------------------------------------------------\n",
        "# Dictionaries can be used with lists and tuples to create complex data structures.\n",
        "\n",
        "# Example 2: List of Dictionaries\n",
        "students = [\n",
        "    {'name': 'Alice', 'grade': 85},\n",
        "    {'name': 'Bob', 'grade': 90},\n",
        "    {'name': 'Charlie', 'grade': 78}\n",
        "]\n",
        "\n",
        "# Sorting list of dictionaries by grade\n",
        "students_sorted_by_grade = sorted(students, key=lambda x: x['grade'], reverse=True)\n",
        "print(\"Students sorted by grade: \", students_sorted_by_grade)\n",
        "\n",
        "# Example 3: Dictionary of Tuples\n",
        "# Using tuples as keys\n",
        "coordinates_info = {(35.6895, 139.6917): \"Tokyo\", (40.7128, -74.0060): \"New York\"}\n",
        "\n",
        "# Assignment 2: Create a dictionary where keys are student names and values are lists of grades. Calculate the average grade for each student.\n",
        "# Write your code below:\n",
        "\n",
        "\n",
        "# Congratulations on completing the advanced section on Python dictionaries!\n",
        "# Review the assignments, try to solve them, and check your understanding of this powerful data structure.\n"
      ],
      "metadata": {
        "id": "ca6ZFa6XI0Xp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "625aedc3-5906-4d27-a4ef-cd0ada1ea230"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "New York\n",
            "30\n",
            "Texas\n",
            "dict_keys(['name', 'age', 'city', 'country'])\n",
            "dict_values(['John', 31, 'New York', 'USA'])\n",
            "dict_items([('name', 'John'), ('age', 31), ('city', 'New York'), ('country', 'USA')])\n",
            "John\n",
            "Removed Value: USA\n",
            "Dictionary after pop():  {'name': 'John', 'age': 31, 'city': 'New York'}\n",
            "Last Item: ('city', 'New York')\n",
            "Dictionary after popitem():  {'name': 'John', 'age': 31}\n",
            "Dictionary after update():  {'name': 'John', 'age': 32, 'email': 'john@example.com'}\n",
            "Dictionary Copy:  {'name': 'John', 'age': 32, 'email': 'john@example.com'}\n",
            "Students sorted by grade:  [{'name': 'Bob', 'grade': 90}, {'name': 'Alice', 'grade': 85}, {'name': 'Charlie', 'grade': 78}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "3Y8YCHVP_IlE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating the student dictionary\n",
        "student = {\n",
        "    'name': 'Md. Ziaul Hoque',\n",
        "    'roll_number': 12345,\n",
        "    'grades': [\n",
        "        {'subject': 'Math', 'marks': 85},\n",
        "        {'subject': 'Physics', 'marks': 90},\n",
        "        {'subject': 'Chemistry', 'marks': 88}\n",
        "    ]\n",
        "}\n",
        "\n",
        "# Displaying the student dictionary\n",
        "print(\"Initial Student Data:\", student)\n",
        "\n",
        "# Adding a new subject and marks\n",
        "new_subject = {'subject': 'Biology', 'marks': 92}\n",
        "student['grades'].append(new_subject)\n",
        "print(\"\\nAfter Adding Biology:\", student)\n",
        "\n",
        "# Modifying marks for a subject and changing 'Chemistry' to 'Bangla'\n",
        "for grade in student['grades']:\n",
        "    if grade['subject'] == 'Physics':\n",
        "        grade['marks'] = 95\n",
        "    elif grade['subject'] == 'Chemistry':\n",
        "        grade.update({'subject': 'Bangla', 'marks': 90})\n",
        "print(\"\\nAfter Modifying Physics Marks and Updating Chemistry to Bangla:\", student)\n",
        "\n",
        "# Removing a subject\n",
        "removed_value = student['grades'].pop(1)\n",
        "print(\"\\nAfter Removing Physics:\", student)\n",
        "\n",
        "# Adding a new key 'age' to the student dictionary\n",
        "student['age'] = 22\n",
        "print(\"\\nAfter Adding Age:\", student)\n",
        "\n",
        "# Removing 'roll_number' from the dictionary\n",
        "del student['roll_number']\n",
        "print(\"\\nAfter Removing Roll Number:\", student)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZcxPC-3A_WHj",
        "outputId": "a0315886-813b-4218-b2cb-02a5743d9ecc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial Student Data: {'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 90}, {'subject': 'Chemistry', 'marks': 88}]}\n",
            "\n",
            "After Adding Biology: {'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 90}, {'subject': 'Chemistry', 'marks': 88}, {'subject': 'Biology', 'marks': 92}]}\n",
            "\n",
            "After Modifying Physics Marks and Updating Chemistry to Bangla: {'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 95}, {'subject': 'Bangla', 'marks': 90}, {'subject': 'Biology', 'marks': 92}]}\n",
            "\n",
            "After Removing Physics: {'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Bangla', 'marks': 90}, {'subject': 'Biology', 'marks': 92}]}\n",
            "\n",
            "After Adding Age: {'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Bangla', 'marks': 90}, {'subject': 'Biology', 'marks': 92}], 'age': 22}\n",
            "\n",
            "After Removing Roll Number: {'name': 'Md. Ziaul Hoque', 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Bangla', 'marks': 90}, {'subject': 'Biology', 'marks': 92}], 'age': 22}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "5BkTCsV_YjEK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a dictionary where keys are student names and values are lists of grades. Calculate the average grade for each student.\n",
        "\n",
        "\n",
        "# Creating the students dictionary\n",
        "students = [\n",
        "    {\n",
        "        'name': 'Md. Ziaul Hoque',\n",
        "        'roll_number': 12345,\n",
        "        'grades': [\n",
        "            {'subject': 'Math', 'marks': 85},\n",
        "            {'subject': 'Physics', 'marks': 90},\n",
        "            {'subject': 'Chemistry', 'marks': 88}\n",
        "        ]\n",
        "    },\n",
        "    {\n",
        "        'name': 'John Doe',\n",
        "        'roll_number': 12346,\n",
        "        'grades': [\n",
        "            {'subject': 'Math', 'marks': 78},\n",
        "            {'subject': 'Physics', 'marks': 80},\n",
        "            {'subject': 'Chemistry', 'marks': 85}\n",
        "        ]\n",
        "    },\n",
        "    {\n",
        "        'name': 'Jane Smith',\n",
        "        'roll_number': 12347,\n",
        "        'grades': [\n",
        "            {'subject': 'Math', 'marks': 92},\n",
        "            {'subject': 'Physics', 'marks': 88},\n",
        "            {'subject': 'Chemistry', 'marks': 90}\n",
        "        ]\n",
        "    }\n",
        "]\n",
        "\n",
        "# Displaying the initial students data\n",
        "print(\"Initial Students Data:\")\n",
        "for student in students:\n",
        "    print(student)\n",
        "\n",
        "# Adding a new subject and marks for each student\n",
        "for student in students:\n",
        "    new_subject = {'subject': 'Biology', 'marks': 89}\n",
        "    student['grades'].append(new_subject)\n",
        "\n",
        "print(\"\\nAfter Adding Biology:\")\n",
        "for student in students:\n",
        "    print(student)\n",
        "\n",
        "#calculating the average grade for each student\n",
        "for student in students:\n",
        "    total_marks = 0\n",
        "    num_subjects = len(student['grades'])\n",
        "    for grade in student['grades']:\n",
        "        total_marks += grade['marks']\n",
        "    average_grade = total_marks / num_subjects\n",
        "    student['average_grade'] = average_grade\n",
        "\n",
        "print(\"\\nAfter Calculating Average Grades:\")\n",
        "for student in students:\n",
        "    print(student)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xWeQLQ7QThdt",
        "outputId": "d8e10f3e-96a7-4c0e-9ecc-dd6b02b0793e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial Students Data:\n",
            "{'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 90}, {'subject': 'Chemistry', 'marks': 88}]}\n",
            "{'name': 'John Doe', 'roll_number': 12346, 'grades': [{'subject': 'Math', 'marks': 78}, {'subject': 'Physics', 'marks': 80}, {'subject': 'Chemistry', 'marks': 85}]}\n",
            "{'name': 'Jane Smith', 'roll_number': 12347, 'grades': [{'subject': 'Math', 'marks': 92}, {'subject': 'Physics', 'marks': 88}, {'subject': 'Chemistry', 'marks': 90}]}\n",
            "\n",
            "After Adding Biology:\n",
            "{'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 90}, {'subject': 'Chemistry', 'marks': 88}, {'subject': 'Biology', 'marks': 89}]}\n",
            "{'name': 'John Doe', 'roll_number': 12346, 'grades': [{'subject': 'Math', 'marks': 78}, {'subject': 'Physics', 'marks': 80}, {'subject': 'Chemistry', 'marks': 85}, {'subject': 'Biology', 'marks': 89}]}\n",
            "{'name': 'Jane Smith', 'roll_number': 12347, 'grades': [{'subject': 'Math', 'marks': 92}, {'subject': 'Physics', 'marks': 88}, {'subject': 'Chemistry', 'marks': 90}, {'subject': 'Biology', 'marks': 89}]}\n",
            "\n",
            "After Calculating Average Grades:\n",
            "{'name': 'Md. Ziaul Hoque', 'roll_number': 12345, 'grades': [{'subject': 'Math', 'marks': 85}, {'subject': 'Physics', 'marks': 90}, {'subject': 'Chemistry', 'marks': 88}, {'subject': 'Biology', 'marks': 89}], 'average_grade': 88.0}\n",
            "{'name': 'John Doe', 'roll_number': 12346, 'grades': [{'subject': 'Math', 'marks': 78}, {'subject': 'Physics', 'marks': 80}, {'subject': 'Chemistry', 'marks': 85}, {'subject': 'Biology', 'marks': 89}], 'average_grade': 83.0}\n",
            "{'name': 'Jane Smith', 'roll_number': 12347, 'grades': [{'subject': 'Math', 'marks': 92}, {'subject': 'Physics', 'marks': 88}, {'subject': 'Chemistry', 'marks': 90}, {'subject': 'Biology', 'marks': 89}], 'average_grade': 89.75}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#4.Strings"
      ],
      "metadata": {
        "id": "SqcVNZ1dZcjW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##practice"
      ],
      "metadata": {
        "id": "UQ6iykv0ZjBc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Advanced Python: Strings\n",
        "\n",
        "\n",
        "# Section 1: String Basics\n",
        "# ------------------------\n",
        "# Strings in Python are sequences of characters.\n",
        "\n",
        "# Example 1: Creating and Using Strings\n",
        "simple_string = \"Hello, Python learners!\"\n",
        "# print(simple_string[0])  # Accessing the first character\n",
        "\n",
        "# Strings are immutable\n",
        "# Trying to change a character directly will raise a TypeError\n",
        "#simple_string[0] = 'h'  # Uncommenting this line will cause an error\n",
        "\n",
        "# String Methods\n",
        "# Finding substrings\n",
        "# print(simple_string.find('python'))  # Returns the start index of 'Python'\n",
        "\n",
        "# Replacing substrings\n",
        "modified_string = simple_string.replace('learners', 'developers')\n",
        "print(\"Modified String:\", modified_string)\n",
        "\n",
        "# Splitting strings\n",
        "# print(simple_string)\n",
        "\n",
        "marks = \"80: 83: 70: 48: 47\"\n",
        "marks_list = marks.split(': ')  # Splits the string into a list of marks\n",
        "print(\"Array of marks:\", marks_list)\n",
        "\n",
        "words = simple_string.split(', ')  # Splits the string into a list of words\n",
        "print(\"Array of words:\", words)\n",
        "\n",
        "# Joining strings\n",
        "joined_string = '-'.join(marks_list)  # Joins the list back into a single string\n",
        "print(\"Joined string:\", joined_string)\n",
        "\n",
        "# Case conversion\n",
        "# print(simple_string.upper())  # Converts to uppercase\n",
        "# print(simple_string.lower())  # Converts to lowercase\n",
        "\n",
        "# Stripping whitespace\n",
        "user_input = \"   some user input   \"\n",
        "# print(user_input)\n",
        "# print(user_input.strip())  # Removes leading and trailing whitespace\n",
        "# print(user_input.rstrip())  # Removes trailing whitespace\n",
        "# print(user_input.lstrip())  # Removes leading whitespace\n",
        "\n",
        "# Assignment 1: Create a string that contains a simple bio data like name, age, and country. Extract each piece of information and print them separately.\n",
        "# Write your code below:\n",
        "\n",
        "\n",
        "# Section 2: Advanced String Operations\n",
        "# -------------------------------------\n",
        "# Strings can be used in more complex operations like formatting.\n",
        "\n",
        "# Example 2: String Formatting\n",
        "name = \"Alice\"\n",
        "age = 30\n",
        "greeting = f\"Hello, my name is {name} and I am {age} years old.\"\n",
        "print(greeting)\n",
        "\n",
        "# Old-style formatting\n",
        "old_greeting = \"Hello, my name is %s and I am %d years old.\" % (name, age)\n",
        "print(old_greeting)\n",
        "\n",
        "\n",
        "# Assignment 2: Create a formatted string that includes data from a list or dictionary. For example, use a dictionary to store a person's information and format a string to include it.\n",
        "# Write your code below:\n",
        "\n",
        "\n",
        "# Section 3: Advanced Slicing and Multiline Strings\n",
        "# -------------------------------------\n",
        "# Python strings are immutable, which means that every string operation creates a new string.\n",
        "\n",
        "# Example 1: Advanced Slicing\n",
        "complex_string = \"Hello, Python enthusiasts!\"\n",
        "reverse_string = complex_string[::-1]  # Reverses the string using slicing\n",
        "# print(reverse_string)\n",
        "\n",
        "# Multiline strings\n",
        "multiline_string = \"\"\"This is a string that spans\n",
        "multiple lines within triple quotes.\"\"\"\n",
        "# print(multiline_string)\n",
        "\n",
        "# Raw strings\n",
        "path = r\"C:\\new_folder\\test.txt\"  # Raw string ignores escape characters\n",
        "print(path)\n",
        "\n",
        "# String Methods\n",
        "# Counting substrings\n",
        "# print(\"The count of 'n' is:\", complex_string.count('n'))\n",
        "\n",
        "# Formatting strings with str.format() and f-strings\n",
        "pi = 3.14159\n",
        "formatted_string = \"The value of pi is {:.2f}\".format(pi)  # Formatting to two decimal places\n",
        "# print(formatted_string)\n",
        "\n",
        "# Assignment 3: Write a function that takes a string and returns a dictionary with the counts of each character in the string.\n",
        "# Write your code below:\n",
        "\n",
        "\n",
        "# Section 4: Regular Expressions\n",
        "# ------------------------------\n",
        "# Regular expressions are used for pattern matching in strings.\n",
        "\n",
        "\n",
        "import re\n",
        "\n",
        "# Basic Regex: Matching Literal Strings\n",
        "pattern = 'earth'\n",
        "text = 'Hello, world!'\n",
        "match = re.search(pattern, text)\n",
        "if match:\n",
        "    print(\"Match found:\", match.group())\n",
        "else:\n",
        "    print(\"No match found.\")\n",
        "\n",
        "\n",
        "# Character Classes\n",
        "pattern = r'\\d+'  # Matches one or more digits\n",
        "text = 'There are 123 apples, 45 oranges, and 78 bananas.'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Numbers found:\", matches)\n",
        "\n",
        "# Alternation and Grouping\n",
        "pattern = r'apple|banana'  # Matches 'apple' or 'banana'\n",
        "text = 'I like apples, oranges.'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Fruits found:\", matches)\n",
        "\n",
        "\n",
        "# Positive Lookahead\n",
        "pattern = r'\\d{3}(?=px)'  # Matches a number only if it's followed by 'px'\n",
        "text = 'The 487 image is 106px by 209px.'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Numbers followed by 'px':\", matches)\n",
        "\n",
        "# Non-capturing Group\n",
        "pattern = r'(?:\\d{3}-)?\\d{3}-\\d{4}'  # Matches phone numbers with optional area code\n",
        "text = 'Call 415-555-1234 or 555-4321 or 008-718-6897'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Phone numbers found:\", matches)\n",
        "\n",
        "\n",
        "# Example: Email Validation\n",
        "# A more detailed regex for validating an email address.\n",
        "email_regex = r\"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$\"\n",
        "email = \"example@domain.com\"\n",
        "email = \"example@domain\"\n",
        "if re.match(email_regex, email):\n",
        "    print(\"Valid email!\")\n",
        "else:\n",
        "    print(\"Invalid email!\")\n",
        "\n",
        "\n",
        "# Example: Extracting Phone Numbers\n",
        "# Regex to match US phone number formats\n",
        "phone_regex = r\"\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b\"\n",
        "text = \"Call me at 415-555-1011 tomorrow, or 564-9712 or at 415.555.9999 for office line.\"\n",
        "phones = re.findall(phone_regex, text)\n",
        "print(\"Phone numbers found:\", phones)\n",
        "\n",
        "# Example: Replacing Text\n",
        "# Replacing all occurrences of digits with a placeholder\n",
        "replaced_text = re.sub(r'\\d', 'X', 'My number: 12345, office: 98765')\n",
        "print(\"Censored text:\", replaced_text)\n",
        "\n",
        "# Assignment: Write a regex to find all the hashtags in a string.\n",
        "text_with_hashtags = \"This is a #great day to learn #regex in #Python!\"\n",
        "\n",
        "\n",
        "# Assignments: Write a regex to find the Bangladesh phone number with all variations.\n",
        "# 01454565767\n",
        "# +880196345634\n",
        "# 0088785674657\n",
        "# 01845-567567\n",
        "\n",
        "# Congratulations on completing the advanced section on Python strings!\n",
        "# Review the assignments, try to solve them, and check your understanding of string manipulation techniques.\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "73TumEy5Zeyj",
        "outputId": "54ac5136-f724-486b-b8ae-60f2535223ec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Modified String: Hello, Python developers!\n",
            "Array of marks: ['80', '83', '70', '48', '47']\n",
            "Array of words: ['Hello', 'Python learners!']\n",
            "Joined string: 80-83-70-48-47\n",
            "Hello, my name is Alice and I am 30 years old.\n",
            "Hello, my name is Alice and I am 30 years old.\n",
            "C:\\new_folder\\test.txt\n",
            "No match found.\n",
            "Numbers found: ['123', '45', '78']\n",
            "Fruits found: ['apple']\n",
            "Numbers followed by 'px': ['106', '209']\n",
            "Phone numbers found: ['415-555-1234', '555-4321', '008-718-6897']\n",
            "Invalid email!\n",
            "Phone numbers found: ['415-555-1011', '415.555.9999']\n",
            "Censored text: My number: XXXXX, office: XXXXX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "gYluyTY-ZmLJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Create a string that contains a simple bio data like name, age, and country. Extract each piece of information and print them separately.\n",
        "students = [\n",
        "    \"Md. Ziaul Hoque, 25, Bangladesh\",\n",
        "    \"Amite Dey, 25, India\"\n",
        "]\n",
        "for student in students:\n",
        "    name, age, country = student.split(', ')\n",
        "    print(\"Name:\", name)\n",
        "    print(\"Age:\", age)\n",
        "    print(\"Country:\", country)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H-HyNZBCZn5U",
        "outputId": "6be16cfe-a323-43d3-86c7-05006cd9b85e"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: Md. Ziaul Hoque\n",
            "Age: 25\n",
            "Country: Bangladesh\n",
            "Name: Amite Dey\n",
            "Age: 25\n",
            "Country: India\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "GfY4jzQ6d2L8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a formatted string that includes data from a list or dictionary. For example, use a dictionary to store a person's information and format a string to include it.\n",
        "# Dictionary to store a person's information\n",
        "person_info = {\n",
        "    \"name\": \"Md. Ziaul Hoque\",\n",
        "    \"age\": 25,\n",
        "    \"profession\": \"AI Engineer\",\n",
        "    \"location\": \"Chittagong, Bangladesh\"\n",
        "}\n",
        "\n",
        "# Formatted string using the dictionary\n",
        "formatted_string = (\n",
        "    f\"My name is {person_info['name']}. \"\n",
        "    f\"I am {person_info['age']} years old, working as a {person_info['profession']}. \"\n",
        "    f\"I live in {person_info['location']}.\"\n",
        ")\n",
        "\n",
        "print(formatted_string)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8ecA5bGdaSFW",
        "outputId": "20b03b44-a8c5-4c73-dbe1-802e77174ddd"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Md. Ziaul Hoque. I am 25 years old, working as a AI Engineer. I live in Chittagong, Bangladesh.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "practice"
      ],
      "metadata": {
        "id": "F6T4F4F1e6y0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 2: String Formatting\n",
        "name = \"Alice\"\n",
        "age = 30\n",
        "greeting = f\"Hello, my name is {name} and I am {age} years old.\"\n",
        "print(greeting)\n",
        "\n",
        "# Old-style formatting\n",
        "old_greeting = \"Hello, my name is %s and I am %d years old.\" % (name, age)\n",
        "print(old_greeting)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t4L-bEYhhL_g",
        "outputId": "0a8f9504-f5f7-4308-ab47-402efe2a40ae"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, my name is Alice and I am 30 years old.\n",
            "Hello, my name is Alice and I am 30 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "complex_string = \"Hello, Python enthusiasts!\"\n",
        "reverse_string = complex_string[::-1]  # Reverses the string using slicing\n",
        "print(reverse_string)\n",
        "print(complex_string[::2])\n",
        "print(\"The count of 'n' is:\", complex_string.count('n'))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lMNPekomeyek",
        "outputId": "778c7fe1-2b28-4046-ba69-c99a85050ec0"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "!stsaisuhtne nohtyP ,olleH\n",
            "Hlo yhnetuiss\n",
            "The count of 'n' is: 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiline strings\n",
        "multiline_string = \"\"\"This is a string that spans\n",
        "multiple lines within triple quotes.\"\"\"\n",
        "print(multiline_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "edPJHP9rffDi",
        "outputId": "31f691cb-8560-406b-cd3a-428430e5d5ad"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a string that spans\n",
            "multiple lines within triple quotes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Raw strings\n",
        "path = r\"C:\\new_folder\\test.txt\"  # Raw string ignores escape characters\n",
        "print(path)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uzjWBSgVf3a0",
        "outputId": "b082747b-2a4a-452e-ddb8-4ac7348bbad4"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "C:\\new_folder\\test.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Formatting strings with str.format() and f-strings\n",
        "pi = 3.14159\n",
        "formatted_string = \"The value of pi is {:.2f}\".format(pi)  # Formatting to two decimal places\n",
        "print(formatted_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yJ_QRjh_gwRI",
        "outputId": "53a7f15b-8836-460f-fa8c-a5625e8d9972"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The value of pi is 3.14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-3"
      ],
      "metadata": {
        "id": "WP4mm298h9to"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 3: Write a function that takes a string and returns a dictionary with the counts of each character in the string.\n",
        "def count_characters(input_string):\n",
        "    \"\"\"\n",
        "    Counts the occurrences of each character in the given string.\n",
        "\n",
        "    Args:\n",
        "        input_string (str): The string to analyze.\n",
        "\n",
        "    Returns:\n",
        "        dict: A dictionary with characters as keys and their counts as values.\n",
        "    \"\"\"\n",
        "    char_counts = {}\n",
        "    for char in input_string:\n",
        "        if char in char_counts:\n",
        "            char_counts[char] += 1\n",
        "        else:\n",
        "            char_counts[char] = 1\n",
        "    return char_counts\n",
        "\n",
        "sample_string = \"Ziaul Hoque Khasru\"\n",
        "result = count_characters(sample_string)\n",
        "print(result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OntjYAVYh_mX",
        "outputId": "5a1dbbf4-077e-49db-ae46-36a5cda4cf72"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Z': 1, 'i': 1, 'a': 2, 'u': 3, 'l': 1, ' ': 2, 'H': 1, 'o': 1, 'q': 1, 'e': 1, 'K': 1, 'h': 1, 's': 1, 'r': 1}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "practice"
      ],
      "metadata": {
        "id": "HqZhVusjjStq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "# Basic Regex: Matching Literal Strings\n",
        "pattern = 'earth'\n",
        "text = 'Hello, world!'\n",
        "match = re.search(pattern, text)\n",
        "if match:\n",
        "    print(\"Match found:\", match.group())\n",
        "else:\n",
        "    print(\"No match found.\")\n",
        "\n",
        "\n",
        "pattern = 'earth'\n",
        "text = 'Hello, earth, i know the earth is round!'\n",
        "match = re.search(pattern, text)\n",
        "if match:\n",
        "    print(\"Match found:\", match)\n",
        "    print(\"Match found:\", match.group())\n",
        "\n",
        "else:\n",
        "    print(\"No match found.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xTiYYwFSjT8D",
        "outputId": "cfb09718-ebf6-4f23-ac84-5f938ee61128"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No match found.\n",
            "Match found: <re.Match object; span=(7, 12), match='earth'>\n",
            "Match found: earth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "# Basic Regex: Matching Literal Strings\n",
        "pattern = 'earth'\n",
        "text = 'Hello, world!'\n",
        "match = re.search(pattern, text)\n",
        "if match:\n",
        "    print(\"Match found:\", match.group())\n",
        "else:\n",
        "    print(\"No match found.\")\n",
        "\n",
        "\n",
        "pattern = 'earth'\n",
        "text = 'Hello, earth, i know the earth is round!'\n",
        "match = re.findall(pattern, text) # match is now a list of strings\n",
        "if match:\n",
        "    print(\"Match found:\", match)\n",
        "    # print(\"Match found:\", match.group()) # match is a list, so group() method is not available\n",
        "    for m in match:  # Iterate through the list of matches and print each one\n",
        "        print(\"Match found:\", m)\n",
        "\n",
        "else:\n",
        "    print(\"No match found.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XjRYa_mXmVcn",
        "outputId": "eddff406-fe50-4464-e513-7f0b4416d305"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No match found.\n",
            "Match found: ['earth', 'earth']\n",
            "Match found: earth\n",
            "Match found: earth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "# Character Classes\n",
        "pattern = r'\\d+'  # Matches one or more digits, r indicates its a raw string\n",
        "text = 'There are 123 apples, 45 oranges, and 78 bananas.'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Numbers found:\", matches)\n",
        "\n",
        "# Alternation and Grouping\n",
        "pattern = r'apple|banana'  # Matches 'apple' or 'banana'\n",
        "text = 'I like apples, oranges.'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Fruits found:\", matches)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nCdgg1m_lvq1",
        "outputId": "3fc9779c-afb5-4f0e-b303-8b204639b58a"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Numbers found: ['123', '45', '78']\n",
            "Fruits found: ['apple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Non-capturing Group\n",
        "pattern = r'(?:\\d{3}-)?\\d{3}-\\d{4}'  # Matches phone numbers with optional area code\n",
        "text = 'Call 415-555-1234 or 555-4321 or 008-718-6897'\n",
        "matches = re.findall(pattern, text)\n",
        "print(\"Phone numbers found:\", matches)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GbquvDXbnDvu",
        "outputId": "68470cb6-003d-4af1-f14f-179318a573bd"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Phone numbers found: ['415-555-1234', '555-4321', '008-718-6897']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Email Validation\n",
        "# A more detailed regex for validating an email address.\n",
        "email_regex = r\"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$\"\n",
        "email = \"example@domain.com\"\n",
        "#email = \"example@domain\"\n",
        "if re.match(email_regex, email):\n",
        "    print(\"Valid email!\")\n",
        "else:\n",
        "    print(\"Invalid email!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "41rH5EozoYfn",
        "outputId": "6a5e08db-2dac-4edc-ba7f-02293d80b4b2"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Invalid email!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Extracting Phone Numbers\n",
        "# Regex to match US phone number formats\n",
        "phone_regex = r\"\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b\"\n",
        "text = \"Call me at 415-555-1011 tomorrow, or 564-9712 or at 415.555.9999 for office line.\"\n",
        "phones = re.findall(phone_regex, text)\n",
        "print(\"Phone numbers found:\", phones)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-0-oCIzAvUQR",
        "outputId": "483e29c9-92a7-4ea2-8b35-7c2c78fde0ae"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Phone numbers found: ['415-555-1011', '415.555.9999']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "def find_all_emails(text):\n",
        "    \"\"\"\n",
        "    Finds all email addresses within a given text using a regular expression.\n",
        "\n",
        "    Args:\n",
        "        text (str): The text to search for email addresses.\n",
        "\n",
        "    Returns:\n",
        "        list: A list of email addresses found in the text.\n",
        "    \"\"\"\n",
        "    email_regex = r\"[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+\"\n",
        "    # Note: This regex is a slightly simplified version for broader matching\n",
        "\n",
        "    emails = re.findall(email_regex, text)\n",
        "    return emails\n",
        "\n",
        "# Example usage:\n",
        "text = \"Contact us at support@example.com or sales@company.co.uk for inquiries.\"\n",
        "emails_found = find_all_emails(text)\n",
        "print(\"Emails found:\", emails_found)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zgrDtT7KvUT0",
        "outputId": "cae2ad10-b277-43d0-bc31-6af1878bc5db"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Emails found: ['support@example.com', 'sales@company.co.uk']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-4"
      ],
      "metadata": {
        "id": "3Pznqv1p05oK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment: Write a regex to find all the hashtags in a string.\n",
        "text_with_hashtags = \"This is a #great day to learn #regex in #Python!\"\n",
        "hashtag_regex = r\"#\\w+\"\n",
        "hashtags = re.findall(hashtag_regex, text_with_hashtags)\n",
        "print(\"Hashtags found:\", hashtags)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uX3RAcCB09xu",
        "outputId": "d44bb1fe-7364-4dc2-984b-a2002b7a7b1c"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hashtags found: ['#great', '#regex', '#Python']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-5"
      ],
      "metadata": {
        "id": "gW85w4Mp1Shn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignments: Write a regex to find the Bangladesh phone number with all variations.\n",
        "# 01454565767\n",
        "# +880196345634\n",
        "# 01845-567567\n",
        "import re\n",
        "\n",
        "# Regex to match Bangladesh phone numbers\n",
        "bangladesh_phone_regex = r\"(?:\\+?880|0)1[3-9]\\d{8}\"\n",
        "\n",
        "# Example usage\n",
        "test_numbers = [\n",
        "    \"01454565767\",\n",
        "    \"+880196345634\",\n",
        "    \"0088785674657\",\n",
        "    \"+8801712345678\",\n",
        "    \"01845-567567\"\n",
        "    \"8801612345678\",\n",
        "    \"01712345678\",\n",
        "    \"+880 1812 345 678\",\n",
        "    \"018-1234-5678\",\n",
        "    \"016 12345678\"\n",
        "]\n",
        "\n",
        "# Finding matches\n",
        "for number in test_numbers:\n",
        "    if re.fullmatch(bangladesh_phone_regex, number.replace(\" \", \"\").replace(\"-\", \"\")):\n",
        "        print(f\"Valid: {number}\")\n",
        "    else:\n",
        "        print(f\"Invalid: {number}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "htd08G0L1VCF",
        "outputId": "1065be25-0675-4205-fa10-48da8ba9d81f"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Valid: 01454565767\n",
            "Invalid: +880196345634\n",
            "Invalid: 0088785674657\n",
            "Valid: +8801712345678\n",
            "Invalid: 01845-5675678801612345678\n",
            "Valid: 01712345678\n",
            "Valid: +880 1812 345 678\n",
            "Valid: 018-1234-5678\n",
            "Valid: 016 12345678\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "dXQ-Altz3w7l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#5.Conditional"
      ],
      "metadata": {
        "id": "Peei034H3xEM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "bWr9rrTN31Tj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Write a Python script that determines if a number is positive, negative, or zero using if-elif-else.\n",
        "number = 5\n",
        "if number > 0:\n",
        "    print(\"The number is positive.\")\n",
        "elif number < 0:\n",
        "    print(\"The number is negative.\")\n",
        "else:\n",
        "    print(\"The number is zero.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XSfdlIB03zer",
        "outputId": "6fd9d056-65ad-4a49-839b-f9f24d04f1c6"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number is positive.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "o0RZqm6f4OwQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "eDAnvDQN4O2f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a script that checks if a person is eligible for a senior citizen discount based on age and residency.\n",
        "age=45\n",
        "residency = \"USA\"\n",
        "if(age>=45 and residency==\"USA\"):\n",
        "  print(\"You are eligible for senior citizen discount\")\n",
        "else:\n",
        "  print(\"You are not eligible for senior citizen discount\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZJev9BKl4RRu",
        "outputId": "c9da5db0-06cb-4e8f-dde3-c9a328ed2049"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You are eligible for senior citizen discount\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-3"
      ],
      "metadata": {
        "id": "8nvnLm_I4stT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 3: Write a script that simulates a basic login system. Check username and password correctness.\n",
        "username = \"ziaulhoque\"\n",
        "password = \"password12345\"\n",
        "entered_username = input(\"Enter your username: \")\n",
        "entered_password = input(\"Enter your password: \")\n",
        "if entered_username == username and entered_password == password:\n",
        "    print(\"Login successful!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "goCuvmKA4xP6",
        "outputId": "b70fbda8-2a13-4c16-f3d3-074a8e83eb0f"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your username: ziaulhoque\n",
            "Enter your password: password12345\n",
            "Login successful!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-4"
      ],
      "metadata": {
        "id": "x6DWiAtX5V3B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 4: Implement a system that categorizes a day based on temperature and weather conditions.\n",
        "def categorize_day(temperature, weather_condition):\n",
        "    \"\"\"\n",
        "    Categorizes a day based on temperature and weather conditions.\n",
        "\n",
        "    Args:\n",
        "        temperature (float): The temperature in degrees Celsius.\n",
        "        weather_condition (str): The weather condition (e.g., \"sunny\", \"rainy\", \"cloudy\").\n",
        "\n",
        "    Returns:\n",
        "        str: The category of the day.\n",
        "    \"\"\"\n",
        "    # Define categories based on temperature and weather conditions\n",
        "    if weather_condition.lower() == \"rainy\":\n",
        "        if temperature < 20:\n",
        "            return \"Cold and Rainy\"\n",
        "        elif 20 <= temperature <= 30:\n",
        "            return \"Pleasant but Rainy\"\n",
        "        else:\n",
        "            return \"Hot and Rainy\"\n",
        "    elif weather_condition.lower() == \"sunny\":\n",
        "        if temperature < 20:\n",
        "            return \"Cold and Sunny\"\n",
        "        elif 20 <= temperature <= 30:\n",
        "            return \"Pleasant and Sunny\"\n",
        "        else:\n",
        "            return \"Hot and Sunny\"\n",
        "    elif weather_condition.lower() == \"cloudy\":\n",
        "        if temperature < 20:\n",
        "            return \"Cold and Cloudy\"\n",
        "        elif 20 <= temperature <= 30:\n",
        "            return \"Pleasant and Cloudy\"\n",
        "        else:\n",
        "            return \"Humid and Cloudy\"\n",
        "    else:\n",
        "        return \"Uncategorized Weather\"\n",
        "\n",
        "temperature = 25  # in degrees Celsius\n",
        "weather_condition = \"Sunny\"\n",
        "category = categorize_day(temperature, weather_condition)\n",
        "print(f\"The day is categorized as: {category}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZrbzFkGQ5YIJ",
        "outputId": "c4bfa11b-1d4a-45c1-fbe7-0ba8d628f327"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The day is categorized as: Pleasant and Sunny\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#6.Loop"
      ],
      "metadata": {
        "id": "5blghdTT6UZB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 5: Nested for loops with dictionaries\n",
        "students = {\n",
        "    \"Alice\": {\"math\": 90, \"science\": 85},\n",
        "    \"Bob\": {\"math\": 75, \"science\": 92}\n",
        "}\n",
        "for student, grades in students.items():\n",
        "    print(f\"{student}'s grades:\")\n",
        "    for subject, grade in grades.items():\n",
        "        print(f\"{subject}: {grade}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kjorwlVT7zkm",
        "outputId": "a01a9a93-465b-4ccf-eb10-af903c2155a2"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice's grades:\n",
            "math: 90\n",
            "science: 85\n",
            "Bob's grades:\n",
            "math: 75\n",
            "science: 92\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 6: Real-world application - Inventory Management\n",
        "inventory = {\n",
        "    \"apples\": 50,\n",
        "    \"bananas\": 20,\n",
        "    \"oranges\": 75\n",
        "}\n",
        "min_threshold = 30\n",
        "discount_threshold = 60\n",
        "discount_rate = 0.1\n",
        "\n",
        "for item, quantity in inventory.items():\n",
        "    if quantity < min_threshold:\n",
        "        print(f\"Reorder {item}.\")\n",
        "    elif quantity > discount_threshold:\n",
        "        print(f\"Apply a {discount_rate*100}% discount on {item}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4RJWmYLT6YAb",
        "outputId": "5837433f-a40d-4a13-f145-bc6378e47d8a"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reorder bananas.\n",
            "Apply a 10.0% discount on oranges.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "kggLzw4K8gAE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Write a script that processes a list of temperature readings. If any temperature is above a certain threshold, print a warning.\n",
        "temp = [23.3,15.8,45.7,60,40,30]\n",
        "threshold = 29\n",
        "for i in temp:\n",
        "  if i > threshold:\n",
        "    print(f\"Warning: Temperature {i} is above the threshold {threshold}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "McfPBcmb8he9",
        "outputId": "afbac06d-1f8d-457b-d785-25bb40ec3868"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Warning: Temperature 45.7 is above the threshold 29\n",
            "Warning: Temperature 60 is above the threshold 29\n",
            "Warning: Temperature 40 is above the threshold 29\n",
            "Warning: Temperature 30 is above the threshold 29\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 7: User Activity Log Analysis\n",
        "# This example processes a list of user activity logs to identify users who performed specific actions.\n",
        "\n",
        "activity_logs = [\n",
        "    {\"user\": \"Alice\", \"action\": \"login\"},\n",
        "    {\"user\": \"Bob\", \"action\": \"logout\"},\n",
        "    {\"user\": \"Alice\", \"action\": \"upload\"},\n",
        "    {\"user\": \"Charlie\", \"action\": \"login\"},\n",
        "    {\"user\": \"Alice\", \"action\": \"logout\"}\n",
        "]\n",
        "\n",
        "actions_count = {}\n",
        "for log in activity_logs:\n",
        "    user = log[\"user\"]\n",
        "    action = log[\"action\"]\n",
        "    if user not in actions_count:#dictionary user entry\n",
        "        actions_count[user] = {}\n",
        "    if action in actions_count[user]:\n",
        "        actions_count[user][action] += 1\n",
        "    else:\n",
        "        actions_count[user][action] = 1\n",
        "\n",
        "print(\"User actions count:\", actions_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tMfsKD2S9g6l",
        "outputId": "f7160358-f503-4597-9170-7fd7707d0cbc"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "User actions count: {'Alice': {'login': 1, 'upload': 1, 'logout': 1}, 'Bob': {'logout': 1}, 'Charlie': {'login': 1}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "h8sfca63BBpC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Create a script that processes a dictionary of products, checking stock levels and generating restock alerts if necessary.\n",
        "products = {\n",
        "    \"laptop\": {\"stock\": 4, \"min_required\": 10},\n",
        "    \"smartphone\": {\"stock\": 15, \"min_required\": 5}\n",
        "}\n",
        "for product, details in products.items():\n",
        "    stock = details[\"stock\"]\n",
        "    print(f\"Current stock of {product} is {stock}\")\n",
        "    min_required = details[\"min_required\"]\n",
        "    if stock < min_required:\n",
        "        print(f\"Restock {product}! Current stock: {stock}\")\n",
        "    print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QlKJ3ORbBDg3",
        "outputId": "be795c2c-1bc2-4598-d6d1-c44e8514eaf5"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current stock of laptop is 4\n",
            "Restock laptop! Current stock: 4\n",
            "\n",
            "Current stock of smartphone is 15\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##7.Function"
      ],
      "metadata": {
        "id": "bRluEtRIBr1v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Functions can have default parameters and accept variable numbers of arguments.\n",
        "# Example 4: Default Arguments and *args, **kwargs\n",
        "def create_profile(name, email, *interests, **details):\n",
        "    \"\"\"Creates a user profile dictionary with given details.\"\"\"\n",
        "    profile = {\n",
        "        \"name\": name,\n",
        "        \"email\": email,\n",
        "        \"interests\": interests,\n",
        "        \"details\": details\n",
        "    }\n",
        "    # process profile\n",
        "\n",
        "    return profile\n",
        "\n",
        "profile = create_profile(\"Bob\", \"bob@example.com\", \"nasheed\", \"art\",30, age=25, location=\"New York\")\n",
        "print(profile)\n",
        "profile = create_profile(\"Bob\", \"bob@example.com\", \"nasheed\", \"art\", \"calliography\", age=35)\n",
        "print(profile)\n",
        "profile = create_profile(\"Bob\", \"bob@example.com\", \"swimming\", \"art\", \"calliography\", \"listening_quran\", age=27, location=\"Chicago\")\n",
        "print(profile)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RSNzyznVCR8B",
        "outputId": "b4ffbb18-0064-4431-dbb6-72ad5eb22320"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Bob', 'email': 'bob@example.com', 'interests': ('nasheed', 'art', 30), 'details': {'age': 25, 'location': 'New York'}}\n",
            "{'name': 'Bob', 'email': 'bob@example.com', 'interests': ('nasheed', 'art', 'calliography'), 'details': {'age': 35}}\n",
            "{'name': 'Bob', 'email': 'bob@example.com', 'interests': ('swimming', 'art', 'calliography', 'listening_quran'), 'details': {'age': 27, 'location': 'Chicago'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Section 4: Advanced Function Concepts\n",
        "# -------------------------------------\n",
        "\n",
        "# Decorators enhance the behavior of functions, and lambda functions allow for concise function definitions.\n",
        "\n",
        "# Example 3: Using Decorators for Logging\n",
        "def log_function_data(func):\n",
        "    \"\"\"Decorator to log function usage.\"\"\"\n",
        "    def wrapper(*args, **kwargs):\n",
        "        print(f\"{func.__name__} was called with args: {args} and kwargs: {kwargs}\")\n",
        "        # save into database with args & kwargs\n",
        "        if args[0]<5:\n",
        "          print(\"args[0] is less than 5\")\n",
        "          return\n",
        "        return func(*args, **kwargs)\n",
        "    return wrapper\n",
        "\n",
        "@log_function_data\n",
        "def auth(username, password):\n",
        "    \"\"\"Simulates user authentication.\"\"\"\n",
        "    if username == \"admin\" and password == \"password\":\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "user = input(\"Enter username: \")\n",
        "password = input(\"Enter password: \")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y72BlklqDBPh",
        "outputId": "bc91c940-d145-41fb-a829-6e13b8200a89"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "add was called with args: (5, 5) and kwargs: {}\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "a5CVfPtZByTv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Write a function that calculates the factorial of a number and handles any potential errors.\n",
        "def factorial(n):\n",
        "    \"\"\"\n",
        "    Calculates the factorial of a number.\"\"\"\n",
        "    i=1\n",
        "    while n:\n",
        "      if n==0:\n",
        "        return n\n",
        "      else:\n",
        "        i=i*n\n",
        "        n=n-1\n",
        "    return i\n",
        "print(factorial(5))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hvRW2rS2Bti-",
        "outputId": "857c2ba7-8041-480c-eceb-f7a130021e6d"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#8. Files"
      ],
      "metadata": {
        "id": "IlrAIlAiGP48"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "E-PYeBsVGaZv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Write a script that reads a CSV file containing product information and converts it into a JSON file.\n",
        "import csv\n",
        "import json\n",
        "import numpy as np\n",
        "# Step 1: Create a CSV file with product information\n",
        "csv_file_path = \"products.csv\"\n",
        "csv_data = [\n",
        "    [\"ProductID\", \"Name\", \"Price\", \"Stock\"],\n",
        "    [\"101\", \"Laptop\", \"800\", \"10\"],\n",
        "    [\"102\", \"Mouse\", \"20\", \"50\"],\n",
        "    [\"103\", \"Keyboard\", \"30\", \"30\"],\n",
        "    [\"104\", \"Monitor\", \"200\", \"20\"],\n",
        "    [\"105\",np.nan,\"10\",\"100\"]\n",
        "]\n",
        "\n",
        "# Write data to CSV file\n",
        "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
        "    writer = csv.writer(csv_file)\n",
        "    writer.writerows(csv_data)\n",
        "\n",
        "print(f\"CSV file '{csv_file_path}' created successfully.\")\n",
        "\n",
        "# Step 2: Read the CSV file and convert it to JSON\n",
        "json_file_path = \"products.json\"\n",
        "\n",
        "def csv_to_json(csv_file_path, json_file_path):\n",
        "    \"\"\"\n",
        "    Converts a CSV file to a JSON file.\n",
        "\n",
        "    Args:\n",
        "        csv_file_path (str): The path to the input CSV file.\n",
        "        json_file_path (str): The path to the output JSON file.\n",
        "    \"\"\"\n",
        "    with open(csv_file_path, mode='r') as csv_file:\n",
        "        csv_reader = csv.DictReader(csv_file)\n",
        "        data = [row for row in csv_reader]\n",
        "\n",
        "    with open(json_file_path, mode='w') as json_file:\n",
        "        json.dump(data, json_file, indent=4)\n",
        "\n",
        "    print(f\"JSON file '{json_file_path}' created successfully.\")\n",
        "\n",
        "# Perform the conversion\n",
        "csv_to_json(csv_file_path, json_file_path)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "07vRYfnhGUXT",
        "outputId": "dc6edf9f-520f-45b9-b663-e5d3da97700c"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CSV file 'products.csv' created successfully.\n",
            "JSON file 'products.json' created successfully.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "fLWtcBTOKXpV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a log file writer that appends log messages to a file with timestamps.\n",
        "\n",
        "from datetime import datetime\n",
        "\n",
        "def write_log(message, log_file=\"app.log\"):\n",
        "    # current time\n",
        "    timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
        "    # Format the log message\n",
        "    log_entry = f\"[{timestamp}] {message}\\n\"\n",
        "    # adding the log message to the log file\n",
        "    with open(log_file, mode=\"a\") as file:\n",
        "        file.write(log_entry)\n",
        "    print(f\"Log message written to '{log_file}'.\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    write_log(\"Application started\")\n",
        "    write_log(\"An error occurred while processing user input\")\n",
        "    write_log(\"Application terminated\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DdNz2l5EIlcT",
        "outputId": "88997123-8404-4007-e1b1-949e360433ca"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Log message written to 'app.log'.\n",
            "Log message written to 'app.log'.\n",
            "Log message written to 'app.log'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#9.Math_datetime"
      ],
      "metadata": {
        "id": "3TFOafvCLZ0u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "I6rc3ynSLhtR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Write a function that calculates compound interest using the formula A = P(1 + r/n)^(nt).\n",
        "def compound_interest(principal, rate, time,n):\n",
        "  return principal*(1.0+rate/n)**(n*time)\n",
        "print(f\" The compud interest is {compound_interest(12000,.1,5,1):.3f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VYS-Rg7KLdC4",
        "outputId": "44c1258c-b5b6-4e8e-ddc5-a3cb7bf47b06"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " The compud interest is 19326.120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-2"
      ],
      "metadata": {
        "id": "61fUFkBnOvSW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a formatted string that includes data from a list or dictionary. For example, use a dictionary to store a person's information and format a string to include it.\n",
        "# Dictionary containing a person's information\n",
        "person = {\n",
        "    \"name\": \"Md. Ziaul Hoque\",\n",
        "    \"age\": 24,\n",
        "    \"country\": \"Bangladesh\",\n",
        "    \"profession\": \"Machine Learning Engineer\"\n",
        "}\n",
        "\n",
        "# Create a formatted string using the dictionary\n",
        "formatted_string = (\n",
        "    f\"Name: {person['name']}\\n\"\n",
        "    f\"Age: {person['age']}\\n\"\n",
        "    f\"Country: {person['country']}\\n\"\n",
        "    f\"Profession: {person['profession']}\"\n",
        ")\n",
        "\n",
        "# Print the formatted string\n",
        "print(\"Formatted String:\")\n",
        "print(formatted_string)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gUETZracO0C6",
        "outputId": "bd57417a-b8b6-4ef0-d7b0-ea053cbd0eb1"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Formatted String:\n",
            "Name: Md. Ziaul Hoque\n",
            "Age: 24\n",
            "Country: Bangladesh\n",
            "Profession: Machine Learning Engineer\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-3"
      ],
      "metadata": {
        "id": "HIPkl8ZlQHog"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a script that prints the current time and updates every second.\n",
        "import time\n",
        "from datetime import datetime\n",
        "\n",
        "def display_time():\n",
        "    \"\"\"\n",
        "    Prints the current time and updates every second.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        while True:\n",
        "            # Get the current time\n",
        "            current_time = datetime.now().strftime(\"%H:%M:%S\")\n",
        "\n",
        "            # Print the current time (overwrite the same line)\n",
        "            print(f\"\\rCurrent Time: {current_time}\", end=\"\")\n",
        "\n",
        "            # Wait for 1 second\n",
        "            time.sleep(1)\n",
        "    except KeyboardInterrupt:\n",
        "        # Handle graceful exit when user presses Ctrl+C\n",
        "        print(\"\\nTime display stopped.\")\n",
        "        print(\"used gpt help\")\n",
        "\n",
        "# Run the function\n",
        "if __name__ == \"__main__\":\n",
        "    display_time()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9iUJursuQJ1C",
        "outputId": "f7f7ffbf-1933-451e-947f-8c1a1b5a03c9"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current Time: 17:42:46\n",
            "Time display stopped.\n",
            "used gpt help\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Create a script that prints the current time and updates every second.\n",
        "import time\n",
        "from datetime import datetime\n",
        "\n",
        "def display_time():\n",
        "    \"\"\"\n",
        "    Prints the current time and updates every second.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        while True:\n",
        "            # Get the current time in 12-hour format with AM/PM\n",
        "            current_time = datetime.now().strftime(\"%I:%M:%S %p\")\n",
        "\n",
        "            # Print the current time (overwrite the same line)\n",
        "            print(f\"\\rCurrent Time: {current_time}\", end=\"\")\n",
        "\n",
        "            # Wait for 1 second\n",
        "            time.sleep(1)\n",
        "    except KeyboardInterrupt:\n",
        "        # Handle graceful exit when user presses Ctrl+C\n",
        "        print(\"\\nTime display stopped.\")\n",
        "        print(\"used gpt help\")\n",
        "\n",
        "# Run the function\n",
        "if __name__ == \"__main__\":\n",
        "    display_time()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bbFVPKj1RLOB",
        "outputId": "4032a0c8-1a43-41a6-9427-7f1868ad0f03"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current Time: 05:44:51 PM\n",
            "Time display stopped.\n",
            "used gpt help\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#10.module_package_library"
      ],
      "metadata": {
        "id": "0X54oNdtRhap"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assignment-1"
      ],
      "metadata": {
        "id": "RRCagPSGRmKY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 1: Create a simple package with at least two modules, each containing one function.\n",
        "\n",
        "import os\n",
        "\n",
        "# Step 1: Create the 'simple_package' directory structure\n",
        "package_dir = 'simple_package'\n",
        "os.makedirs(package_dir, exist_ok=True)\n",
        "\n",
        "# Step 2: Create 'module1.py' file inside 'simple_package'\n",
        "module1_code = \"\"\"\n",
        "# module1.py\n",
        "\n",
        "def greet(name):\n",
        "    \\\"\"\"Function to greet a person\\\"\"\"\n",
        "    return f\"Hello, {name}!\"\n",
        "\"\"\"\n",
        "with open(f'{package_dir}/module1.py', 'w') as f:\n",
        "    f.write(module1_code)\n",
        "\n",
        "# Step 3: Create 'module2.py' file inside 'simple_package'\n",
        "module2_code = \"\"\"\n",
        "# module2.py\n",
        "\n",
        "def add_numbers(a, b):\n",
        "    \\\"\"\"Function to add two numbers\\\"\"\"\n",
        "    return a + b\n",
        "\"\"\"\n",
        "with open(f'{package_dir}/module2.py', 'w') as f:\n",
        "    f.write(module2_code)\n",
        "\n",
        "# Step 4: Create '__init__.py' file to mark 'simple_package' as a package\n",
        "with open(f'{package_dir}/__init__.py', 'w') as f:\n",
        "    f.write('')\n",
        "\n",
        "# Step 5: Create 'main.py' file to use the package\n",
        "main_code = \"\"\"\n",
        "# main.py\n",
        "from simple_package.module1 import greet\n",
        "from simple_package.module2 import add_numbers\n",
        "\n",
        "# Using the greet function\n",
        "print(greet(\"Md. Ziaul Hoque\"))\n",
        "\n",
        "# Using the add_numbers function\n",
        "result = add_numbers(5, 7)\n",
        "print(f\"The sum of 5 and 7 is: {result}\")\n",
        "\"\"\"\n",
        "with open('main.py', 'w') as f:\n",
        "    f.write(main_code)\n",
        "\n",
        "# Final message\n",
        "print(\"Package and script have been created. You can now run main.py.\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5iUWNwEJRlSz",
        "outputId": "520df4d6-971a-4cdd-91cc-973775b79f26"
      },
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Package and script have been created. You can now run main.py.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Assgnment-2"
      ],
      "metadata": {
        "id": "d4dH9rIuTkTs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assignment 2: Use pip to install any library that is new to you and write a small script to explore its functionality.\n",
        "!pip install nump\n",
        "import numpy as np\n",
        "print(np.random.randint(1,10))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q0mLf5XTTm-8",
        "outputId": "bfb38b3b-05f5-44a3-eb6a-9cf63a08dc72"
      },
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting nump\n",
            "  Downloading nump-5.5.5.5-py3-none-any.whl.metadata (358 bytes)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from nump) (1.26.4)\n",
            "Downloading nump-5.5.5.5-py3-none-any.whl (1.1 kB)\n",
            "Installing collected packages: nump\n",
            "Successfully installed nump-5.5.5.5\n",
            "6\n"
          ]
        }
      ]
    }
  ]
}