Function_001.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyP2kd402f3j+b2iMsCFjp0y",
      "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/soumyasankar99/Python_from_scratch/blob/main/Function_001.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "FUNCTION WITHOUT PARAMETERS:"
      ],
      "metadata": {
        "id": "Po6HUzKKdOlw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![08gvrn19k0q3jfkexvob.webp](data:image/webp;base64,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)"
      ],
      "metadata": {
        "id": "aMi02QtCrmv2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ag6D0jsMdKTp",
        "outputId": "952da418-0cc8-4eca-9c78-275750a7ce1d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "soumya sankar\n"
          ]
        }
      ],
      "source": [
        "def my_full_name ():\n",
        "  first_name = \"soumya\"\n",
        "  last_name =\"sankar\"\n",
        "  space=' '\n",
        "  full_name = first_name + space + last_name\n",
        "  print(full_name)\n",
        "\n",
        "my_full_name()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def Run_a_car():\n",
        "  start =\"start a car by ignit the engine\"\n",
        "  accelerate=\"then speed is now 30/kmh\"\n",
        "  brake=\"car slow down and slows down.\"\n",
        "\n",
        "  mechanism_car= start +\" , \"+ accelerate +\" , \"+ brake\n",
        "  print(mechanism_car)\n",
        "\n",
        "Run_a_car()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cIWS0f40dLx4",
        "outputId": "31795d4a-ac70-41af-a185-3ac3dfbba04f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "start a car by ignit the engine , then speed is now 30/kmh , car slow down and slows down.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![images.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "2yt7H_bus9_F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_two_numbers():\n",
        "  num1 = 2\n",
        "  num2 = 3\n",
        "\n",
        "  total = num1 + num2\n",
        "  print(total)\n",
        "\n",
        "add_two_numbers()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vn8FEh97dL00",
        "outputId": "f336a13c-d9ae-43e2-b458-58ee109e4577"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#This is addition operation\n",
        "def add_two_numbers():\n",
        "  num1 = input(\"Enter a number of your 1st choice:\")\n",
        "  num2 = input(\"Enter a number of your 2nd choice:\")\n",
        "\n",
        "  total = num1 + num2\n",
        "  print(\"Total number is:\",total)\n",
        "\n",
        "add_two_numbers()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y3Vln6WMdL4M",
        "outputId": "9d539589-bb22-4d3b-a1a2-fdcdcdf4c7d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number of your 1st choice:1234567890\n",
            "Enter a number of your 2nd choice:09876543211\n",
            "Total number is: 123456789009876543211\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#This is multiplication operation\n",
        "\n",
        "def mul_two_numbers():\n",
        "  num1 = int(input(\"Enter a number of your 1st choice:\"))\n",
        "  num2 = int(input(\"Enter a number of your 2nd choice:\"))\n",
        "\n",
        "  total = num1 * num2\n",
        "  print(\"Total number is:\",total)\n",
        "\n",
        "mul_two_numbers()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UWtyrELydL7e",
        "outputId": "d082257e-2e4d-47a6-a419-7ec7faaff055"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number of your 1st choice:456\n",
            "Enter a number of your 2nd choice:678\n",
            "Total number is: 309168\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function Returning a Value- Part-1\n"
      ],
      "metadata": {
        "id": "YBoft4F3h-Ot"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def Run_a_car():\n",
        "  start =\"start a car by ignit the engine\"\n",
        "  accelerate=\"then speed is now 30/kmh\"\n",
        "  brake=\"car slow down and slows down.\"\n",
        "\n",
        "  mechanism_car= start +\" , \"+ accelerate +\" , \"+ brake\n",
        "  return mechanism_car\n",
        "\n",
        "print(Run_a_car())\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EikxZ8_EiFR_",
        "outputId": "f236fcfd-901a-431d-dd3d-c383f5115278"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "start a car by ignit the engine , then speed is now 30/kmh , car slow down and slows down.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function with Parameters"
      ],
      "metadata": {
        "id": "rDYqvdYFjQtZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.lib.display import Code\n",
        "#syntax\n",
        "#declaring a function\n",
        "\n",
        "def function_name(parameter):\n",
        "  Code\n",
        "  codes\n",
        "\n",
        "#Calling function\n",
        "print(function_name(argument))"
      ],
      "metadata": {
        "id": "e3zDn-mLdL_r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def greetings (name):\n",
        "    message = name + ', welcome to Python for Everyone!'\n",
        "    return message\n",
        "\n",
        "print(greetings('Soumya sankar'))\n",
        "\n",
        "def add_ten(num):\n",
        "    ten = 10\n",
        "    return num + ten\n",
        "print(add_ten(90))\n",
        "\n",
        "def square_number(x):\n",
        "    return x * x\n",
        "print(square_number(2))\n",
        "\n",
        "def area_of_circle (r):\n",
        "    PI = 3.14\n",
        "    area = PI * r ** 2\n",
        "    return area\n",
        "print(area_of_circle(10))\n",
        "\n",
        "def sum_of_numbers(n):\n",
        "    total = 0\n",
        "    for i in range(n+1):\n",
        "        total+=i\n",
        "    print(total)\n",
        "print(sum_of_numbers(10)) # 55\n",
        "print(sum_of_numbers(100)) # 5050"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8zWetFK_jYaV",
        "outputId": "14e0deb8-d331-4abc-e57d-3a7da276eb5b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soumya sankar, welcome to Python for Everyone!\n",
            "100\n",
            "4\n",
            "314.0\n",
            "55\n",
            "None\n",
            "5050\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Two Parameters ▶"
      ],
      "metadata": {
        "id": "VBnIMa5Bl6vU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "  # syntax\n",
        "  # Declaring a function\n",
        "  def function_name(para1, para2):\n",
        "    codes\n",
        "    codes\n",
        "  # Calling function\n",
        "  print(function_name(arg1, arg2))"
      ],
      "metadata": {
        "id": "5_1BRyn0jYd3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_full_name (first_name, last_name):\n",
        "   space = ' '\n",
        "   full_name = first_name + space + last_name\n",
        "   return full_name\n",
        "print('Full Name: ', generate_full_name('Soumya','Sankar'))\n",
        "\n",
        "def sum_two_numbers (num_one, num_two):\n",
        "    sum = num_one + num_two\n",
        "    return sum\n",
        "print('Sum of two numbers: ', sum_two_numbers(1, 9))\n",
        "\n",
        "def calculate_age (current_year, birth_year):\n",
        "    age = current_year - birth_year\n",
        "    return age;\n",
        "\n",
        "print('Age: ', calculate_age(2021, 1819))\n",
        "\n",
        "def weight_of_object (mass, gravity):\n",
        "    weight = str(mass * gravity)+ ' N' # the value has to be changed to a string first\n",
        "    return weight\n",
        "print('Weight of an object in Newtons: ', weight_of_object(100, 9.81))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ONmpyBm7jYgu",
        "outputId": "d4d2c6ef-eccc-49de-d5de-53749e109885"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Full Name:  Soumya Sankar\n",
            "Sum of two numbers:  10\n",
            "Age:  202\n",
            "Weight of an object in Newtons:  981.0 N\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# syntax\n",
        "# Declaring a function\n",
        "def function_name(para1, para2):\n",
        "    codes\n",
        "    codes\n",
        "# Calling function\n",
        "print(function_name(para1 = 'John', para2 = 'Doe')) # the order of arguments does not matter here"
      ],
      "metadata": {
        "id": "NawA_akkjYko"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def print_fullname(firstname, lastname):\n",
        "    space = ' '\n",
        "    full_name = firstname  + space + lastname\n",
        "    print(full_name)\n",
        "print(print_fullname(firstname = 'Soumya', lastname = 'Panda'))\n",
        "\n",
        "def add_two_numbers (num1, num2):\n",
        "    total = num1 + num2\n",
        "    print(total)\n",
        "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dEo8TmUrjYm4",
        "outputId": "e53c18fc-cd24-4ce5-a941-3a5be8e796f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soumya Panda\n",
            "None\n",
            "5\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def print_name(firstname):\n",
        "    return firstname\n",
        "print_name('Soumya') # Soumya\n",
        "\n",
        "def print_full_name(firstname, lastname):\n",
        "    space = ' '\n",
        "    full_name = firstname  + space + lastname\n",
        "    return full_name\n",
        "print_full_name(firstname='Soumya', lastname='Sankar')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ihlEKtTkjYqZ",
        "outputId": "5e545238-e6c4-46f6-a842-f2080603e830"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Soumya Sankar'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def add_two_numbers (num1, num2):\n",
        "    total = num1 + num2\n",
        "    return total\n",
        "print(add_two_numbers(2, 3))\n",
        "\n",
        "def calculate_age (current_year, birth_year):\n",
        "    age = current_year - birth_year\n",
        "    return age;\n",
        "print('Age: ', calculate_age(2019, 1819))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1j_RCEzwjYyY",
        "outputId": "b44ad20a-4cdf-49e6-dde7-54497633d342"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "Age:  200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def add_two_numbers(num1,num2):\n",
        "  total = num1 + num2\n",
        "  return total\n",
        "\n",
        "print(add_two_numbers(2,3))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "krqSrtI_1Rba",
        "outputId": "843e19e6-7722-4a21-b70c-0cadc5846bd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def calculation_age(current_year,birth_year):\n",
        "  age = current_year - birth_year\n",
        "  return age;\n",
        "\n",
        "print('Age:',calculate_age(2023,1999))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WuPgp1xs1Rel",
        "outputId": "99b4e88b-c7fb-499f-8eb3-a7b7f60267b0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Age: 24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Returning a boolean:"
      ],
      "metadata": {
        "id": "jKYPUUiw2j4I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_even(n):\n",
        "  if n % 2 == 0:\n",
        "    print('even')\n",
        "    return True  # return stops further execution of the function , similar to break\n",
        "  return False\n",
        "\n",
        "print(is_even(10)) #True\n",
        "print(is_even(7)) #False"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fnJvWxw1Rib",
        "outputId": "e2b7194d-a4f5-4e2a-fe7d-cafc1723a039"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "even\n",
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Returning a list:"
      ],
      "metadata": {
        "id": "uCylBbY74iOW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def find_even_numbers(n):\n",
        "   evens = []\n",
        "   for i in range(n+1):\n",
        "    if i % 2 == 0:\n",
        "       evens.append(i)\n",
        "   return evens\n",
        "print(find_even_numbers(10))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wL3yKZBB1RmD",
        "outputId": "836edcc8-fff1-4ae3-b8bc-cc9daf1b63a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function with Default Parameters"
      ],
      "metadata": {
        "id": "w4zbPiyE53Sj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# syntax\n",
        "# Declaring a function\n",
        "def function_name(param = value):\n",
        "    codes\n",
        "    codes\n",
        "# Calling function\n",
        "function_name()\n",
        "function_name(arg)"
      ],
      "metadata": {
        "id": "KTVcbMHZ1Rrh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def greetings (name = 'Soumya'):\n",
        "    message = name + ', welcome to Python for Everyone!'\n",
        "    return message\n",
        "print(greetings())\n",
        "print(greetings('Sankar'))\n",
        "\n",
        "def generate_full_name (first_name = 'Soumya', last_name = 'Sankar'):\n",
        "    space = ' '\n",
        "    full_name = first_name + space + last_name\n",
        "    return full_name\n",
        "\n",
        "print(generate_full_name())\n",
        "print(generate_full_name('Debarpit','Samal'))\n",
        "\n",
        "def calculate_age (birth_year,current_year = 2023):\n",
        "    age = current_year - birth_year\n",
        "    return age;\n",
        "print('Age: ', calculate_age(1999))\n",
        "\n",
        "def weight_of_object (mass, gravity = 9.81):\n",
        "    weight = str(mass * gravity)+ ' N' # the value has to be changed to string first\n",
        "    return weight\n",
        "print('Weight of an object in Newtons: ', weight_of_object(100)) # 9.81 - average gravity on Earth's surface\n",
        "print('Weight of an object in Newtons: ', weight_of_object(100, 1.62)) # gravity on the surface of the Moon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2rUUSATn6F4y",
        "outputId": "710a93e6-63e6-4dd6-e68c-0d6f4553f1a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soumya, welcome to Python for Everyone!\n",
            "Sankar, welcome to Python for Everyone!\n",
            "Soumya Sankar\n",
            "Debarpit Samal\n",
            "Age:  24\n",
            "Weight of an object in Newtons:  981.0 N\n",
            "Weight of an object in Newtons:  162.0 N\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Arbitrary Number of Arguments\n",
        "\n",
        "If we do not know the number of arguments we pass to our function, we can create a function which can take arbitrary number of arguments by adding * before the parameter name.\n"
      ],
      "metadata": {
        "id": "h1VjgvpY7ccY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# syntax\n",
        "# Declaring a function\n",
        "def function_name(*args):\n",
        "    codes\n",
        "    codes\n",
        "# Calling function\n",
        "function_name(param1, param2, param3,..)"
      ],
      "metadata": {
        "id": "OQ4McTFd6F8k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_all_nums(*nums):\n",
        "  total = 0\n",
        "  for num in nums:\n",
        "    total += num\n",
        "  return total\n",
        "\n",
        "print(sum_all_nums(2,3,5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iKQt-zcc6GAV",
        "outputId": "bc4359d7-eb01-4b82-df47-a8f6c6ae0c29"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Default and Arbitrary Number of Parameters in Functions"
      ],
      "metadata": {
        "id": "zY2oWn7V8YBS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_groups(team,*args):\n",
        "  print(team)\n",
        "  for i in args:\n",
        "    print(i)\n",
        "\n",
        "print(generate_groups('Team-1','Soumya','Sankar','samlik','Juili'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mA5ems5A6GFA",
        "outputId": "cc2e0340-db16-4e7b-e623-7291b375cab0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Team-1\n",
            "Soumya\n",
            "Sankar\n",
            "samlik\n",
            "Juili\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Function as a Parameter of Another Function"
      ],
      "metadata": {
        "id": "0cUEYziR9jtk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#You can pass functions around as parameters\n",
        "def square_number (n):\n",
        "    return n * n\n",
        "def do_something(f, x):\n",
        "    return f(x)\n",
        "print(do_something(square_number, 3)) # 27"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T9KH9nGp6GI7",
        "outputId": "c893e340-8a37-4740-d2aa-51db20d453e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Exercise level -1"
      ],
      "metadata": {
        "id": "iQuZZgBMAqT1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q1) Declare a function add_two_numbers. It takes two parameters and it returns a sum."
      ],
      "metadata": {
        "id": "Ffoy56HoAurr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_two_numbers(num1,num2):\n",
        "  total = num1 + num2\n",
        "  return total\n",
        "\n",
        "print(add_two_numbers(.05,55))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i-yJPn-g6GMt",
        "outputId": "a9304778-5d91-4b6c-bca1-1d46ecf9363a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "55.05\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q2) Area of a circle is calculated as follows: area = π x r x r. Write a function that calculates area_of_circle."
      ],
      "metadata": {
        "id": "zyD9OtmYBiwg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def area_of_circle():\n",
        "  pi = 22/7\n",
        "  r = int(input('Enter a number:'))\n",
        "  area = pi*r*r\n",
        "  print(area)\n",
        "\n",
        "area_of_circle()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yYrdtpZZ6GdT",
        "outputId": "b5b7e0a6-966e-4eba-e048-4509561ada18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number:34\n",
            "3633.1428571428573\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q3) Write a function called add_all_nums which takes arbitrary number of arguments and sums all the arguments. Check if all the list items are number types. If not do give a reasonable feedback."
      ],
      "metadata": {
        "id": "OegqvB1mDT4J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_all_nums(*args):\n",
        "  total = 0 # Initialize the sum to 0\n",
        "\n",
        "  # Check if all arguments are numbers and sum them\n",
        "  for num in args:\n",
        "    if not isinstance(num,(int,float)):\n",
        "      return \"Error: All arguments must be numbers.\"\n",
        "    total += num\n",
        "\n",
        "  return total\n",
        "\n",
        "result = add_all_nums(1,2,3,4,5)\n",
        "print(result)\n",
        "\n",
        "result = add_all_nums(1,2,'3',4,5)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vB429MkDBhRt",
        "outputId": "af5bddd7-0b90-4c2b-8cf3-bd1ebb478c1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "Error: All arguments must be numbers.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q4)Temperature in °C can be converted to °F using this formula: °F = (°C x 9/5) + 32. Write a function which converts °C to °F, convert_celsius_to-fahrenheit."
      ],
      "metadata": {
        "id": "7-VSvik_Es52"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convert_celsius_to_fahrenheit(celsius):\n",
        "  #Formula to convert Celsius to Fahrenheit\n",
        "  fahrenheit = (celsius *(9/5)) + 32\n",
        "  return fahrenheit\n",
        "\n",
        "# Example usage:\n",
        "celsius_temperature = 25\n",
        "fahrenheit_tem = convert_celsius_to_fahrenheit(celsius_temperature)\n",
        "\n",
        "print(f\"{celsius_temperature}°C is equal to {fahrenheit_tem}°F\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bzhYCEvWEsAL",
        "outputId": "b2aacc48-63d6-4a8d-a02c-4c9cd68c22a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25°C is equal to 77.0°F\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q5) Write a function called check-season, it takes a month parameter and returns the season: Autumn, Winter, Spring or Summer."
      ],
      "metadata": {
        "id": "r4YRS4x1IiZU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def check_season(month):\n",
        "  #define a dictionary mapping months to seasons\n",
        "  month_to_season = {\n",
        "      \"December\":\"Winter\",\n",
        "      \"January\" :\"Winter\",\n",
        "      \"February\":\"Spring\",\n",
        "      \"March\":\"Spring\",\n",
        "      \"April\":\"summer\",\n",
        "      \"May\":\"summer\",\n",
        "      \"June\":\"summer\",\n",
        "      \"july\":\"Rainny\",\n",
        "      \"August\":\"Rainny\",\n",
        "      \"September\":\"Rainny\",\n",
        "      \"October\":\"Autum\",\n",
        "      \"November\": \"Autum\"\n",
        "\n",
        "  }\n",
        "\n",
        "  #Check if the provided month is in the dictionary\n",
        "\n",
        "  if month in month_to_season:\n",
        "    return month_to_season[month]\n",
        "  else:\n",
        "    return \"Invalid month\"\n",
        "\n",
        "\n",
        "#Example usage :\n",
        "input_month = str(input(\"Enter a Month Name:\" ))\n",
        "result = check_season(input_month)\n",
        "print(f\"The season for {input_month} is {result}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nSwTcn6jEr0K",
        "outputId": "428e3d42-0ae6-44ef-c524-d7215996aae4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a Month Name:April\n",
            "The season for April is summer\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q6)Write a function called calculate_slope which return the slope of a linear equation"
      ],
      "metadata": {
        "id": "JlH0KPFZ25w6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_slope(x1,y1,x2,y2):\n",
        "  \"\"\"\n",
        "  Calculate the slope of a linear equation given two points on the line\n",
        "\n",
        "  Parameters:\n",
        "       x1 (float): x-coordinate of the first point.\n",
        "       y1 (float): y- coordinate of the first point.\n",
        "       x2 (float): x-coordinate of the second point.\n",
        "       y2 (float): y-coordinate of the second point.\n",
        "  Returns :\n",
        "     float: The slope of the linear equation.\n",
        "\n",
        "\n",
        "  \"\"\"\n",
        "\n",
        "  if x1==x2:\n",
        "    raise ValueError(\"The two points have the same x-coordinate, resulting in undefined slope.\")\n",
        "\n",
        "  slope = (y2-y1)/(x2-x1)\n",
        "  return slope\n",
        "\n",
        "print(calculate_slope(23,34,56,65))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KYKVrv6D24xT",
        "outputId": "f04c9194-5a0a-41f9-c43e-46dd56c4dd4a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9393939393939394\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q7)Quadratic equation is calculated as follows: ax² + bx + c = 0. Write a function which calculates solution set of a quadratic equation, solve_quadratic_eqn."
      ],
      "metadata": {
        "id": "c9kPh6S_5GkY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def solve_quadratic_eqn(a,b,c):\n",
        "  \"\"\"\n",
        "  Solve a quadratic equation of the form ax2+ bx + c = 0 and return the solutions.\n",
        "\n",
        "  Parameters:\n",
        "\n",
        "   a (float) : Coefficient of x2.\n",
        "   b (float) : Coefficient of x.\n",
        "   c (float) : Constant term.\n",
        "\n",
        "\n",
        "  Returns:\n",
        "      tuple : A tuple containg the solutions,which may include real and/or complex\n",
        "      numbers\n",
        "   \"\"\"\n",
        "\n",
        "\n",
        "  discriminant= b**2 - 4*a*c\n",
        "\n",
        "  if discriminant > 0:\n",
        "  #Two real and distinct solutions\n",
        "    root1= (-b + math.sqrt(discriminant))/(2*a)\n",
        "    root2= (-b - math.sqrt(discriminant))/(2*a)\n",
        "    return(root1,root2)\n",
        "\n",
        "  elif discriminant == 0:\n",
        "  # One real solution (a repeated root)\n",
        "      root1 = -b / (2*a)\n",
        "      return (root1,)\n",
        "\n",
        "  else:\n",
        "        # Complex solutions\n",
        "        real_part = -b / (2*a)\n",
        "        imaginary_part = math.sqrt(abs(discriminant)) / (2*a)\n",
        "        root1 = complex(real_part, imaginary_part)\n",
        "        root2 = complex(real_part, -imaginary_part)\n",
        "        return (root1, root2)\n",
        "\n",
        "print(solve_quadratic_eqn(23,34,56))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vIZk_Fne24tn",
        "outputId": "108a5ce6-48fb-4fbe-bbc9-a2c73202ef73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "((-0.7391304347826086+1.3742157068938354j), (-0.7391304347826086-1.3742157068938354j))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q8)Declare a function named print_list. It takes a list as a parameter and it prints out each element of the list."
      ],
      "metadata": {
        "id": "BPOSoVgr9QFA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def print_list(my_list):\n",
        "\n",
        "  for items in my_list:\n",
        "      print(items)\n",
        "\n",
        "\n",
        "my_list = [\"Soumya\",\"Sankar\",\"Samlik\",\"swayam\",\"Mansasmyukta\"]\n",
        "print_list(my_list)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U0yf7NRf24qX",
        "outputId": "b911c1f0-0f93-492d-e230-9e5646bc2f35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soumya\n",
            "Sankar\n",
            "Samlik\n",
            "swayam\n",
            "Mansasmyukta\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q9) Declare a function named reverse_list. It takes an array as a parameter and it returns the reverse of the array (use loops)."
      ],
      "metadata": {
        "id": "MCEB0pC_-GiW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def reverse_list(arr):\n",
        "\n",
        "  \"\"\"\n",
        "  Reverse an array using loops.\n",
        "\n",
        "  Parameters:\n",
        "     arr(list): The array to be reversed.\n",
        "\n",
        "   Returns:\n",
        "     list: The reversed array.\n",
        "\n",
        "  \"\"\"\n",
        "  reversed_arr =[]\n",
        "  for i in range(len(arr) -1,-1,-1):\n",
        "    reversed_arr.append(arr[i])\n",
        "  return reversed_arr\n",
        "\n",
        "#examples:\n",
        "original_list = [1,2,3,4,5]\n",
        "reversed_list = reverse_list(original_list)\n",
        "print(reverse_list)"
      ],
      "metadata": {
        "id": "kYhfkWiM24eo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11561dd5-fedd-41c7-ef6f-bb3f6ad3dc47"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<function reverse_list at 0x7f46ab29db40>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def reverse_list(arr):\n",
        "    \"\"\"\n",
        "    Reverse an array using loops.\n",
        "\n",
        "    Parameters:\n",
        "        arr (list): The array to be reversed.\n",
        "\n",
        "    Returns:\n",
        "        list: The reversed array.\n",
        "    \"\"\"\n",
        "    reversed_arr = []\n",
        "    for i in range(len(arr) - 1, -1, -1):\n",
        "        reversed_arr.append(arr[i])\n",
        "    return reversed_arr\n",
        "\n",
        "# Example usage:\n",
        "print(reverse_list([1, 2, 3, 4, 5]))\n",
        "# Output: [5, 4, 3, 2, 1]\n",
        "\n",
        "print(reverse_list([\"A\", \"B\", \"C\"]))\n",
        "# Output: [\"C\", \"B\", \"A\"]\n"
      ],
      "metadata": {
        "id": "TBtn8Hg-Erwf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75cd0678-3ec5-40c9-d098-4111751dbafc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 4, 3, 2, 1]\n",
            "['C', 'B', 'A']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 10) Declare a function named capitalize_list_items. It takes a list as a parameter and it returns a capitalized list of items"
      ],
      "metadata": {
        "id": "YonjzJpojg-4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def capitalize_list_items(input_list):\n",
        "  capitalized_list = [item.capitalize() for item in input_list]\n",
        "  return capitalized_list\n",
        "\n",
        "\n",
        "original_list = [\"apple\",\"banana\",\"cherry\"]\n",
        "capitalized_result = capitalize_list_items(original_list)\n",
        "print(capitalized_result)\n",
        "\n",
        "\"\"\"\n",
        "Capitalize each item in a list and return a new list.\n",
        "\n",
        "Parameters:\n",
        "    input_list(list): The list of items to be capitalized.\n",
        "\n",
        "Returns:\n",
        "   list: Anew list with capitalized items.\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "nNb0F58RErs8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eec061b1-ee31-4d7e-f8ba-f1dd1da1c4cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Apple', 'Banana', 'Cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 11) Declare a function named add_item. It takes a list and an item parameters. It returns a list with the item added at the end."
      ],
      "metadata": {
        "id": "_U0Pk--cl-bO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk'];\n",
        "\n",
        "print(add_item(food_staff, 'Meat'))     # ['Potato', 'Tomato', 'Mango', 'Milk','Meat'];\n",
        "\n",
        "numbers = [2, 3, 7, 9];\n",
        "print(add_item(numbers, 5))      [2, 3, 7, 9, 5]"
      ],
      "metadata": {
        "id": "nVbDPC9emEYu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_item(input_list, item):\n",
        "  updated_list = input_list.copy()\n",
        "  updated_list.append(item)\n",
        "  return updated_list\n",
        "\n",
        "food_staff = ['Potato','Tomato','Milk']\n",
        "print(add_item(food_staff,'Meat'))\n",
        "\n",
        "numbers = [2,3,7,9]\n",
        "print(add_item(numbers, 5))"
      ],
      "metadata": {
        "id": "PNmgcmK06GfS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bf27783-d58c-4c1f-e4d0-7c27facf9660"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Potato', 'Tomato', 'Milk', 'Meat']\n",
            "[2, 3, 7, 9, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 12) Declare a function named remove_item. It takes a list and an item parameters. It returns a list with the item removed from it."
      ],
      "metadata": {
        "id": "rPCaLswUoBn0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk'];\n",
        "\n",
        "print(remove_item(food_staff, 'Mango'))  # ['Potato', 'Tomato', 'Milk'];\n",
        "\n",
        "numbers = [2, 3, 7, 9];\n",
        "print(remove_item(numbers, 3))  # [2, 7, 9]"
      ],
      "metadata": {
        "id": "Wp-eJW8BoIhU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def remove_item(input_list, item):\n",
        "\n",
        "  updated_list = [x for x in input_list if x!= item]\n",
        "  return updated_list\n",
        "\n",
        "food_staff = ['Potato','Tomato','Mango','Milk']\n",
        "print(remove_item(food_staff,'Mango'))\n",
        "\n",
        "numbers = [2,3,7,9]\n",
        "print(remove_item(numbers,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oPC-pQ-6pHjG",
        "outputId": "42a5e9ee-9f92-4d37-8ae7-644e8917633f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Potato', 'Tomato', 'Milk']\n",
            "[2, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 13) Declare a function named sum_of_numbers. It takes a number parameter and it adds all the numbers in that range."
      ],
      "metadata": {
        "id": "HNs5tQZ-qbRd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_numbers(n):\n",
        "\n",
        "  total = 0\n",
        "  for i in range(1,n+1):\n",
        "    total += i\n",
        "  return total\n",
        "\n",
        "#EXAMPLE\n",
        "result = sum_of_numbers(5)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXKlgsH3pHfM",
        "outputId": "1797dce0-732a-4bf7-e9b6-e0e35eabe351"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_numbers(n):\n",
        "\n",
        "  total = 0\n",
        "  for i in range(1,n+1):\n",
        "    total += i\n",
        "  return total\n",
        "\n",
        "#Example\n",
        "result = sum_of_numbers(15)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UOIwHBwapHbk",
        "outputId": "077130cf-6183-480a-dd05-5e8a328268c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_numbers(n):\n",
        "\n",
        "  total = 0\n",
        "  for i in range(1,n+1):\n",
        "    total += i\n",
        "  return total\n",
        "\n",
        "#Example\n",
        "result = sum_of_numbers(100)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHFua1IhpHZ4",
        "outputId": "48b24b00-99d4-4c68-c358-bfa3e6f6a9e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5050\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 14) Declare a function named sum_of_odds. It takes a number parameter and it adds all the odd numbers in that range."
      ],
      "metadata": {
        "id": "9hre0bZyt25o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_odds(n):\n",
        "\n",
        "  total = 0\n",
        "  for i in range(1,n+1):\n",
        "    if i%2 != 0:  #check i the number is odd\n",
        "       total += i\n",
        "\n",
        "  return total\n",
        "\n",
        "#Example\n",
        "result = sum_of_odds(7)\n",
        "print(result)\n",
        "\n",
        "\"\"\"\n",
        "Calculate the sum of all odd numbers in the range from 1 to n.\n",
        "\n",
        "Parameters:\n",
        "    n(int): The upper limit of the range.\n",
        "\n",
        "Returns:\n",
        "   int: The sum of odd numbers in the specified range.\n",
        "\n",
        "\"\"\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "id": "RvN8M8FPpHUW",
        "outputId": "9c2932a2-a8ba-4d3f-e7b3-4015e0125df1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nCalculate the sum of all odd numbers in the range from 1 to n.\\n\\nParameters:\\n    n(int): The upper limit of the range.\\n\\nReturns:\\n   int: The sum of odd numbers in the specified range.    \\n\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Or you can write it like this way.\n",
        "\n",
        "def sum_of_odds(n):\n",
        "   total = sum(x for x in range(1,n+1) if x % 2 != 0)\n",
        "   return total\n",
        "\n",
        "#Example\n",
        "result = sum_of_odds(7)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4N1KqUMKpHR5",
        "outputId": "1660e017-f31f-4787-b2fc-7218a18398d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# How to calculate sum of odd numbers then ?\n",
        "\n",
        "def sum_of_even(n):\n",
        "\n",
        "    total = sum(x for x in range(1,n+1) if x % 2 == 0)\n",
        "    return total\n",
        "\n",
        "#Examples\n",
        "\n",
        "result = sum_of_even(100)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jXGbNHkgpHMz",
        "outputId": "c80e2a99-ec48-40ab-facb-388ef623d52d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2550\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "  Q 15) Declare a function named sum_of_even. It takes a number parameter and it adds all the even numbers in that - range."
      ],
      "metadata": {
        "id": "psM7wDr7xUgx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_even(n):\n",
        "\n",
        "   total = 0\n",
        "   for i in range(2, n+1 ,2):\n",
        "    total += i\n",
        "   return total\n",
        "\n",
        "#Example usage:\n",
        "result = sum_of_even(100000)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c8rQx8SupHJR",
        "outputId": "82e8cfde-3194-4498-dd0d-e2a37f196ae9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2500050000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for 10,000 result.\n",
        "\n",
        "def sum_of_even(n):\n",
        "\n",
        "  total = 0\n",
        "  for i in range(2, n+1 ,2):\n",
        "    total += i\n",
        "  return total\n",
        "\n",
        "result = sum_of_even(10000)\n",
        "print(result)"
      ],
      "metadata": {
        "id": "4NKc1NGm6Gha",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a4393ac-61a4-4a55-f49b-3ca6d601d021"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25005000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Level 2:"
      ],
      "metadata": {
        "id": "sgXr4VHzLYm0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " Q 1) Write a function called is_prime, which checks if a number is prime."
      ],
      "metadata": {
        "id": "8XGLkJfxLcuJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_prime(number):\n",
        "\n",
        "  if number <= 1:\n",
        "    return False   # 0 and 1 are not prime numbers\n",
        "\n",
        "  if number == 2:\n",
        "    return True    # 2 is a prime number\n",
        "\n",
        "  if number % 2 == 0:\n",
        "    return False #Even numbers greater than 2 are not prime\n",
        "\n",
        "  # Check for divisibility by odd numbers from 3 to the square root of the number\n",
        "  for divisor in range(3,int(number**0.5)+1,2):\n",
        "     if number % divisor == 0:\n",
        "       return False # The number is divisible by a divisor , so it's not prime\n",
        "\n",
        "  return True #The number is prime\n",
        "\n",
        "print(is_prime(17))  # o/p-True = 17\n"
      ],
      "metadata": {
        "id": "lJ6x0YjsLOCS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        " **explanation for the part of the is_prime function that checks for divisibility by odd numbers from 3 to the square root of the given number**"
      ],
      "metadata": {
        "id": "iOfiaDeqOojA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#range(3, int(number**0.5) + 1, 2):\n",
        "\n",
        "This creates a range of numbers starting from 3 up to the square root of the given number (number**0.5) plus 1, with a step size of 2. The step size of 2 ensures that we only check odd numbers as potential divisors, because even numbers greater than 2 cannot be prime.\n",
        "\n",
        "#for divisor in ...:\n",
        "\n",
        "This loop iterates through the odd numbers from 3 up to the square root of the given number.\n",
        "\n",
        "# if number % divisor == 0::\n",
        "\n",
        "Inside the loop, it checks if the given number is divisible by the current divisor. If the remainder (number % divisor) is zero, it means the number is evenly divisible by the divisor.\n",
        "\n",
        "# return False:\n",
        "\n",
        "If the number is found to be divisible by any of the divisors in the loop, the function immediately returns False because a prime number should have exactly two divisors (1 and itself). If it has more than two divisors, it cannot be prime.\n"
      ],
      "metadata": {
        "id": "v5HEkg92OFt1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**  Q 2) Write a functions which checks if all items are unique in the. **"
      ],
      "metadata": {
        "id": "nsTJ3gWUOyTI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def are_all_items_unique(input_list):\n",
        "\n",
        "   unique_set = set()\n",
        "   for item in input_list:\n",
        "    if item in unique_set:\n",
        "         return False\n",
        "    unique_set.add(item)\n",
        "   return True\n",
        "\n",
        "\n",
        "print(are_all_items_unique([1,2,3,4,5]))\n",
        "print(are_all_items_unique([1,2,2,3,4]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ef7NVRLLLOF0",
        "outputId": "433fbb7b-1d8a-48c8-d1f0-49c1b92680aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 3) Write a function which checks if all the items of the list are of the same data type."
      ],
      "metadata": {
        "id": "OP0qhvtodPYb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check if all items in a list are of the same data type.\n",
        "# Parameters-- input_list(list): The list to be checked\n",
        "#Returns: (bool): True if all items are of the same data type, False otherwise"
      ],
      "metadata": {
        "id": "wykM-zRLLONp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def are_all_items_of_same_type(input_list):\n",
        "\n",
        "  if not input_list:\n",
        "    return True     # An empty list is considered to have items of the same type\n",
        "\n",
        "  #Get the data type of the first item in the list\n",
        "  first_item_type = type(input_list[0])\n",
        "\n",
        "  # check if all other items have the same data type\n",
        "  for item in input_list[1:]:\n",
        "    if type(item) != first_item_type:\n",
        "      return False\n",
        "  return True\n",
        "\n",
        "print(are_all_items_of_same_type([1,2,3,4,5]))\n",
        "print(are_all_items_of_same_type(['apple','banana','mango']))\n",
        "print(are_all_items_of_same_type([1,'Soumya',3.99]))\n",
        "print(are_all_items_of_same_type([]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jIdYqCnmdLTO",
        "outputId": "b09e4e96-0c6d-4f72-b2b4-e66bc791a494"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 4)Write a function which check if provided variable is a valid python variable"
      ],
      "metadata": {
        "id": "2i1k8Dtdj4MJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can create a function called \"valid_variable_name\" that checks if a provided variable name is a valid Python name.\n",
        "\n",
        "Rules for it:\n",
        "-------------\n",
        "1.Variable names must start with a letter (a-z,A-Z) or an underscore(_).\n",
        "\n",
        "2.The reamaining charachters can be letters, digits(0-9), or underscores.\n",
        "\n",
        "3.Variable names are case-sensitive."
      ],
      "metadata": {
        "id": "4-hrktGCkRpu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Check if a provided string is a valid Python variable name.\n",
        "\n",
        "# Parameters:\n",
        "#     variable_name (str): The variable name to be checked.\n",
        "\n",
        "#Returns:\n",
        "#   bool: True if the variable name is valid, False otherwise.\n"
      ],
      "metadata": {
        "id": "7I_Nt6vwdLWP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "def valid_variable_name(variable_name):\n",
        "  pattern = r'^[a-zA-Z_][a-zA-Z_0-9_]*$'\n",
        "  return re.match(pattern,variable_name) is not None\n",
        "\n",
        "print(valid_variable_name(\"valid_var\"))\n",
        "print(valid_variable_name('123_sam'))\n",
        "print(valid_variable_name(\"in-variable\"))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LJYRWVoCdLZk",
        "outputId": "b14be30d-f991-4b9b-cccc-aa7fb142d397"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def valid_variable_name(variable_name):\n",
        "\n",
        "  if not variable_name:\n",
        "    return False  #An empty string is not valid variable name\n",
        "\n",
        "  if not (variable_name[0].isalpha() or variable_name[0] == '_'):\n",
        "    return False  # Variable name must start with a letter or underscore\n",
        "\n",
        "  for char in variable_name[1:]:\n",
        "    if not (char.isalpha() or char.isdigit() or char == '_'):\n",
        "      return False  #Invalid character in the variable name\n",
        "\n",
        "  return True\n",
        "\n",
        "\n",
        "print(valid_variable_name(\"valid_var\"))   #True\n",
        "print(valid_variable_name(\"123_valid\"))   #False\n",
        "print(valid_variable_name(\"in-valid\"))    #False"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f5i3M89mdLo7",
        "outputId": "4ea11c9f-ef7c-4777-dac5-bb146773bfc8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Level 3"
      ],
      "metadata": {
        "id": "vbqXoVDOtIJw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 2)Call your function factorial, it takes a whole number as a parameter and it return a factorial of the number"
      ],
      "metadata": {
        "id": "9XpKxXqYtRZT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def factorial(number):\n",
        "\n",
        "    if number < 0:\n",
        "     raise ValueError(\"Factorial is not defined for negative numbers.\")\n",
        "\n",
        "    elif number == 0:\n",
        "     return 1\n",
        "    else:\n",
        "     result = 1\n",
        "     for i in range(1,number + 1):\n",
        "        result *= i\n",
        "     return result\n",
        "\n",
        "# Example usage:\n",
        "result = factorial(10) #  Factorial of 5: 5! = 5*4*3*2*1\n",
        "print(result)"
      ],
      "metadata": {
        "id": "jpzCVcPDLOTK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5303ada1-bd68-41d8-9025-3da99e15ac31"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3628800\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 3)Call your function is_empty, it takes a parameter and it checks if it is empty or not"
      ],
      "metadata": {
        "id": "58B1HzApTJK7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_empty(parameter):\n",
        "  if not parameter:\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "\n",
        "# Example usage:\n",
        "empty_string = \"\"\n",
        "non_empty_string = \"Hello, World!\"\n",
        "empty_list = []\n",
        "non_empty_list = [1,2,3]\n",
        "\n",
        "print(is_empty(empty_string))\n",
        "print(is_empty(non_empty_string))\n",
        "print(is_empty(empty_list))\n",
        "print(is_empty(non_empty_list))"
      ],
      "metadata": {
        "id": "5Nk42T9wtHAY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5743907-d41d-4f9a-d30d-b3d72e09d624"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q 4)Write different functions which take lists. They should calculate_mean, calculate_median, calculate_mode, calculate_range, calculate_variance, calculate_std (standard deviation)."
      ],
      "metadata": {
        "id": "86Wm5hfBUu4k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import statistics\n",
        "\n",
        "def calculate_mean(numbers):\n",
        "  \"\"\"\n",
        "  Calculate the mean (avg) of a list of numbers.\n",
        "\n",
        "  parameters:\n",
        "    numbers (list): The list of numbers.\n",
        "\n",
        "  Returns:\n",
        "     float: The mean of the numbers.\n",
        "  \"\"\"\n",
        "  return sum(numbers)/len(numbers)\n",
        "\n",
        "def calculate_meadian(numbers):\n",
        "  return statistics.median(numbers)\n",
        "\n",
        "\n",
        "def calculate_mode(numbers):\n",
        "  return statistics.mode(numbers)\n",
        "\n",
        "\n",
        "def calculate_range(numbers):\n",
        "  return max(numbers)- min(numbers)\n",
        "\n",
        "\n",
        "def calculate_variance(numbers):\n",
        "  return statistics.variance(numbers)\n",
        "\n",
        "\n",
        "def calculate_std(numbers):\n",
        "  return statistics.stdev(numbers)\n",
        "\n",
        "\n",
        "# Example usage:\n",
        "print('==================================================')\n",
        "data = [1,2,3,4,5,6,7,8,9]\n",
        "print(\"Mean:\",calculate_mean(data))\n",
        "print(\"Median:\", calculate_meadian(data))\n",
        "print(\"Mode:\", calculate_mode(data))\n",
        "print(\"Range:\", calculate_range(data))\n",
        "print(\"Variance:\", calculate_variance(data))\n",
        "print(\"Standard Deviation:\", calculate_std(data))\n",
        "print('===================================================')"
      ],
      "metadata": {
        "id": "kmmyI6-xtHDs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d6be0e28-81d4-441f-9355-f0c9e4cb3efe"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "==================================================\n",
            "Mean: 5.0\n",
            "Median: 5\n",
            "Mode: 1\n",
            "Range: 8\n",
            "Variance: 7.5\n",
            "Standard Deviation: 2.7386127875258306\n",
            "===================================================\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "XJjUDPrutHHC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "piXRTJy5tHK3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OyeghBplLOWQ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}