Python Day 6 - Reference.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Functions and File Handling"
      ],
      "metadata": {
        "id": "5knNdZXqASKw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions in Python\n",
        "A **function** is a reusable block of code that performs a specific task. Functions make your code modular, readable, and easier to maintain.\n",
        "\n",
        "### Why Use Functions?\n",
        "1. **Reusability**: Avoid writing the same code multiple times.\n",
        "2. **Modularity**: Break complex problems into smaller, manageable parts.\n",
        "3. **Readability**: Improve code clarity.\n",
        "\n",
        "### Defining and Calling Functions\n",
        "Syntax:\n",
        "```python\n",
        "def function_name(parameters):\n",
        "    # Function body\n",
        "    return output\n",
        "```\n",
        "\n",
        "```python\n",
        "function_name(arguments)\n",
        "```"
      ],
      "metadata": {
        "id": "CN9FRDfSAT_X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### No Parameters, No Return Value\n",
        "\n",
        "These functions do not accept any input (parameters) and do not return a value.\n",
        "\n",
        "without needing input or output."
      ],
      "metadata": {
        "id": "JIOu7j3KCLk0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet():\n",
        "    print(\"Hello! Welcome to the Python class.\")"
      ],
      "metadata": {
        "id": "-9PCdOMlARTN"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9XSnkLtt9AGk",
        "outputId": "bac67666-7e22-4b70-98b3-b0d9b237b4a7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello! Welcome to the Python class.\n"
          ]
        }
      ],
      "source": [
        "greet()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Parameters, No Return Value\n",
        "\n",
        "These functions accept input (parameters) but do not return any value.\n",
        "\n",
        "They use the input to perform actions."
      ],
      "metadata": {
        "id": "qw_zo3EvCi08"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet_user(name):\n",
        "    print(f\"Hello, {name}! Welcome to the Python class.\")"
      ],
      "metadata": {
        "id": "edeePH43CjxR"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "greet_user(\"Alice\")\n",
        "greet_user(\"Bob\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EBfRePLFCkNC",
        "outputId": "b226e66d-cc97-4c10-fba1-95ec4bff3d4f"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Alice! Welcome to the Python class.\n",
            "Hello, Bob! Welcome to the Python class.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### No Parameters, With Return Value\n",
        "\n",
        "These functions do not take any input but return a value after performing an operation."
      ],
      "metadata": {
        "id": "bvhgj6AzCnH7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_greeting():\n",
        "    return \"Hello! Welcome to the Python class.\""
      ],
      "metadata": {
        "id": "DfbfRxNRC3R_"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "message = get_greeting()\n",
        "print(message)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CgDWvZxvC4wt",
        "outputId": "9b589fee-9d4f-41e7-87bc-2e1daa5a8054"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello! Welcome to the Python class.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Parameters, With Return Value\n",
        "These functions accept input (parameters) and return a value after processing it.\n",
        "This is the most versatile and commonly used function type."
      ],
      "metadata": {
        "id": "l7XCk8RTC8gn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_numbers(a, b):\n",
        "    return a + b"
      ],
      "metadata": {
        "id": "Trm-Sf6iC85G"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "result = add_numbers(5, 3)\n",
        "print(\"Sum:\", result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kltLZIKMC8J3",
        "outputId": "4e0bad39-2c6e-4e80-c49d-45e49fcfad5e"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum: 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Function with default arguments"
      ],
      "metadata": {
        "id": "wigF7VX6DOqw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def introduce(name, age=18):\n",
        "  print(f\"My name is {name} and I am {age} years old.\")\n",
        "\n",
        "introduce(\"Alice\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2XSz4yZYDOMw",
        "outputId": "33b14a15-34b6-463b-c0dd-c10bfbdff7a1"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Alice and I am 18 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using input() for Interactive Functions\n",
        "input() allows functions to interact with users by taking input during runtime."
      ],
      "metadata": {
        "id": "fYV8Rp3nK9NM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_area_of_rectangle():\n",
        "    length = float(input(\"Enter the length: \"))\n",
        "    width = float(input(\"Enter the width: \"))\n",
        "    area = length * width\n",
        "    print(f\"The area of the rectangle is {area}\")\n",
        "\n",
        "calculate_area_of_rectangle()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hdksqFKIK6kX",
        "outputId": "85b0c392-4977-4f1c-a01e-226c2e4738dd"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the length: 5\n",
            "Enter the width: 5\n",
            "The area of the rectangle is 25.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## File Handling in Python\n",
        "File handling is used to read, write, and manipulate files on your system. Python provides built-in functions to handle files efficiently.\n",
        "\n",
        "### Modes in File Handling:\n",
        "* 'r': Read (default mode)\n",
        "* 'w': Write (overwrites if the file exists)\n",
        "* 'a': Append (adds to the end of the file)\n",
        "* 'r+': Read and Write"
      ],
      "metadata": {
        "id": "DkZY1F92Db_S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Opening and Closing a File\n",
        "\n",
        "Syntax:\n",
        "\n",
        "```python\n",
        "file = open(\"filename\", \"mode\")\n",
        "# Perform operations\n",
        "file.close()\n",
        "```\n",
        "\n",
        "```python\n",
        "# Using a with block:\n",
        "with open(\"filename\", \"mode\") as file:\n",
        "    # Perform operations\n",
        "```"
      ],
      "metadata": {
        "id": "6QmHrpLmDqIt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 1: Writing data to a file\n",
        "with open(\"example.txt\", \"w\") as file:\n",
        "  file.write(\"Hello, World!\\n\")\n",
        "  file.write(\"Python file handling is easy!\")\n",
        "\n",
        "print(\"Data written to example.txt\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M9rlvanwDppP",
        "outputId": "13208ca3-feb6-4b45-fbed-e15df61d8238"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data written to example.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 2: Reading from a File\n",
        "with open(\"example.txt\", \"r\") as file:\n",
        "  content = file.read()\n",
        "\n",
        "print(content)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CQaw0tXuEZSk",
        "outputId": "08a0250c-73d8-463f-be02-807eff15946e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, World!\n",
            "Python file handling is easy!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 3: Appending data to a file\n",
        "with open(\"example.txt\", \"a\") as file:\n",
        "  file.write(\"\\nAdding another line to the file.\")\n",
        "\n",
        "print(\"Data appended to example.txt\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fKqSRFiBEfvX",
        "outputId": "1a139703-88fd-45d8-c8dc-ba9e6646eedf"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data appended to example.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"example.txt\", \"r\") as file:\n",
        "  content = file.read()\n",
        "\n",
        "print(content)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tmyeOwcPEtLP",
        "outputId": "5723555e-3672-4dc1-d023-32e783819231"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, World!\n",
            "Python file handling is easy!\n",
            "Adding another line to the file.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 4: Reading a file line by line\n",
        "with open(\"example.txt\", \"r\") as file:\n",
        "  print(\"Reading file line by line:\")\n",
        "  for line in file:\n",
        "    print(line.strip())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-ILmgn_Ex9v",
        "outputId": "470ec5b5-03b3-4778-e834-0cb0fd2d99ff"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading file line by line:\n",
            "Hello, World!\n",
            "Python file handling is easy!\n",
            "Adding another line to the file.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Combining Functions and File Handling"
      ],
      "metadata": {
        "id": "yiZbWFirE-iZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 1: Function to write a list of items to a file\n",
        "def write_items_to_file(filename, items):\n",
        "  with open(filename, \"w\") as file:\n",
        "    for item in items:\n",
        "      file.write(item + \"\\n\")\n",
        "      print(f\"Items written to {filename}\")\n",
        "\n",
        "items = [\"Apple\", \"Banana\", \"Cherry\"]\n",
        "write_items_to_file(\"fruits.txt\", items)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "elhfccJAFFMl",
        "outputId": "835f0e4e-e255-45d6-b1d9-7ccbf803dd9f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Items written to fruits.txt\n",
            "Items written to fruits.txt\n",
            "Items written to fruits.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 2: Function to Read and Print File Content\n",
        "\n",
        "def read_file_content(filename):\n",
        "  with open(filename, \"r\") as file:\n",
        "    print(file.read())\n",
        "\n",
        "read_file_content(\"fruits.txt\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KD7P9DAVFaXh",
        "outputId": "f9405e9b-d5db-4f6f-b53b-4734ba73712d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Apple\n",
            "Banana\n",
            "Cherry\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 3: Function to count words in a file\n",
        "def count_words_in_file(filename):\n",
        "  with open(filename, \"r\") as file:\n",
        "    content = file.read()\n",
        "    words = content.split(\" \")\n",
        "    return len(words)\n",
        "\n",
        "word_count = count_words_in_file(\"example.txt\")\n",
        "print(\"Number of words in example.txt:\", word_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ekzpf5wVFB8z",
        "outputId": "c8f68562-1bc9-4911-e8a4-a54300e0c180"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of words in example.txt: 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Pickle Module for Object Serialization\n",
        "\n",
        "What is Pickle?\n",
        "* Pickle is used to serialize (save) and deserialize (load) Python objects.\n",
        "* Serialization: Convert an object to a byte stream for storage or transmission.\n",
        "* Deserialization: Convert the byte stream back into a Python object."
      ],
      "metadata": {
        "id": "vXTLx0b7LDkW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Save and Load a Dictionary Using Pickle\n",
        "\n",
        "import pickle\n",
        "\n",
        "# Data to save\n",
        "data = {\"name\": \"Alice\", \"age\": 25, \"city\": \"New York\"}\n",
        "\n",
        "# Save data to a pickle file\n",
        "with open(\"data.pkl\", \"wb\") as file:\n",
        "    pickle.dump(data, file)\n",
        "print(\"Data has been serialized and saved.\")\n",
        "\n",
        "# Load data from the pickle file\n",
        "with open(\"data.pkl\", \"rb\") as file:\n",
        "    loaded_data = pickle.load(file)\n",
        "print(\"Loaded Data:\", loaded_data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1O9Dqv87LNfY",
        "outputId": "7e523917-421d-48f6-8cdc-5da4a98a4074"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data has been serialized and saved.\n",
            "Loaded Data: {'name': 'Alice', 'age': 25, 'city': 'New York'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Save and Load a List Using Pickle\n",
        "\n",
        "# Save a list\n",
        "items = [\"Apple\", \"Banana\", \"Cherry\"]\n",
        "with open(\"items.pkl\", \"wb\") as file:\n",
        "    pickle.dump(items, file)\n",
        "print(\"List serialized and saved.\")\n",
        "\n",
        "# Load the list\n",
        "with open(\"items.pkl\", \"rb\") as file:\n",
        "    loaded_items = pickle.load(file)\n",
        "print(\"Loaded List:\", loaded_items)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JpbdKrr3LVXu",
        "outputId": "d41368ff-a3aa-4308-afb9-d31a0e96fda9"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "List serialized and saved.\n",
            "Loaded List: ['Apple', 'Banana', 'Cherry']\n"
          ]
        }
      ]
    }
  ]
}