Python_Basic_Exercise(Part-1)-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a902a263",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Twinkle, twinkle,little star, \n",
      "                How I wonder what you are!\n",
      "                    Up above the world so high,\n",
      "                    Like a diamond in the sky.\n",
      "        Twinkle, twinkle, little star,\n",
      "                How I wonder what you are\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"Twinkle, twinkle,little star, \n",
    "                How I wonder what you are!\n",
    "                    Up above the world so high,\n",
    "                    Like a diamond in the sky.\n",
    "        Twinkle, twinkle, little star,\n",
    "                How I wonder what you are\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2719e7e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version\n",
      "3.9.7 (default, Sep 16 2021, 16:59:28) [MSC v.1916 64 bit (AMD64)]\n",
      "Version Info.\n",
      "sys.version_info(major=3, minor=9, micro=7, releaselevel='final', serial=0)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print (\"Python version\")\n",
    "print(sys.version)\n",
    "print(\"Version Info.\")\n",
    "print(sys.version_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b75c4245",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9.7\n"
     ]
    }
   ],
   "source": [
    "import platform\n",
    "print(platform.python_version())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2555c166",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-08-02 18:49:05.018009\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "now = datetime.datetime.now() # Datetime is a package name as well as module name\n",
    "print(now)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4a3ace63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-08-02 18:49:05\n"
     ]
    }
   ],
   "source": [
    "print (now.strftime(\"%Y-%m-%d %H:%M:%S\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d7146a7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the radius: 1.1\n",
      "The area of the circle with radius 1.1 is :3.8013271108436504\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "radius = float(input (\"Enter the radius: \"))\n",
    "print(\"The area of the circle with radius \" + str(radius) + \" is :\" + str(pi * radius **2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "17097479",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first name: Robert\n",
      "Enter the last name: Martin\n",
      "Martin Robert\n"
     ]
    }
   ],
   "source": [
    "fname = input(\"Enter the first name: \") \n",
    "lname = input(\"Enter the last name: \")\n",
    "\n",
    "print( lname, fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bcf08e1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter numbers with comma separation: 3, 5, 7, 23\n",
      "List :  ['3', ' 5', ' 7', ' 23']\n",
      "Tuple :  ('3', ' 5', ' 7', ' 23')\n"
     ]
    }
   ],
   "source": [
    "num = input(\"Enter numbers with comma separation: \")\n",
    "list = num.split(\",\")\n",
    "tuple = tuple(list)\n",
    "print(\"List : \", list)\n",
    "print('Tuple : ', tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "78d28c1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the file name: abc.java\n",
      "The extension of the file is : 'java'\n"
     ]
    }
   ],
   "source": [
    "file = input(\"Enter the file name: \")\n",
    "f_ext = file.split(\".\")\n",
    "print (\"The extension of the file is : \" + repr(f_ext[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "117ad580",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Black\n"
     ]
    }
   ],
   "source": [
    "color_list = [\"Red\",\"Green\",\"White\" ,\"Black\"]\n",
    "print(color_list[0], color_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "20d5beef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The examination will start from : 11 / 12 / 2014\n"
     ]
    }
   ],
   "source": [
    "exam_st_date = (11, 12, 2014)\n",
    "print(\" The examination will start from : %i / %i / %i\"%exam_st_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c54739fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a  integer number: 5\n",
      "615\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a  integer number: \"))\n",
    "n1 = int( \"%s\"% n)\n",
    "n2 = int( \"%s%s\"% (n,n))\n",
    "n3 = int( \"%s%s%s\"% (n,n,n))\n",
    "\n",
    "print(n1+n2+n3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5a793715",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an integer: 5\n",
      "The result of n+nn+nnn is: 615\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter an integer: \"))\n",
    "result = n + int(str(n) * 2) + int(str(n) * 3)\n",
    "print(f\"The result of n+nn+nnn is: {result}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "359ecbc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return the absolute value of the argument.\n"
     ]
    }
   ],
   "source": [
    "print(abs.__doc__) #Q11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b8e46eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "\n",
      "Prints the values to a stream, or to sys.stdout by default.\n",
      "Optional keyword arguments:\n",
      "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "sep:   string inserted between values, default a space.\n",
      "end:   string appended after the last value, default a newline.\n",
      "flush: whether to forcibly flush the stream.\n"
     ]
    }
   ],
   "source": [
    "print(print.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3ef6560c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    October 2020\n",
      "Mo Tu We Th Fr Sa Su\n",
      "          1  2  3  4\n",
      " 5  6  7  8  9 10 11\n",
      "12 13 14 15 16 17 18\n",
      "19 20 21 22 23 24 25\n",
      "26 27 28 29 30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "print(calendar.month(2020,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5de018c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the year : 2018\n",
      "Input the month : 04\n",
      "     April 2018\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                   1\n",
      " 2  3  4  5  6  7  8\n",
      " 9 10 11 12 13 14 15\n",
      "16 17 18 19 20 21 22\n",
      "23 24 25 26 27 28 29\n",
      "30\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "y = int(input(\"Input the year : \"))\n",
    "m = int(input(\"Input the month : \"))\n",
    "print(calendar.month(y, m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6dc2b81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "a string that you \"don't\" have to escape\n",
      "This\n",
      "is a ....... multi-line\n",
      "heredoc string --------> example\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Q13\n",
    "print(\"\"\"\n",
    "a string that you \"don't\" have to escape\n",
    "This\n",
    "is a ....... multi-line\n",
    "heredoc string --------> example\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f51187f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the year: 2014\n",
      "Input the month: 07\n",
      "Input the date: 02\n",
      "2014-07-02\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "y = int(input(\"Input the year: \"))\n",
    "m = int(input(\"Input the month: \"))\n",
    "d = int(input(\"Input the date: \"))\n",
    "\n",
    "print(datetime.date(y, m, d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6055b475",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "f_date = date(2014,7,2)\n",
    "l_date = date(2014,7,11)\n",
    "delta = l_date - f_date\n",
    "print(delta.days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c7005d54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "904.7786842338603\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "print(4/3 * pi * 6**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e3ea5a5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 14\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a number: \"))\n",
    "\n",
    "if n > 17:\n",
    "    d = (n - 17)*2\n",
    "    print(d)\n",
    "else:\n",
    "    f = 17 - n\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6a928547",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def difference(n):\n",
    "    if n <= 17:\n",
    "        return 17 - n\n",
    "    else:\n",
    "        return (n - 17) * 2 \n",
    "\n",
    "print(difference(22))\n",
    "print(difference(14))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c15cb600",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def near_thousand(n) :\n",
    "    return ((abs(1000 - n) <= 100) or (abs(2000 - n) <= 100))\n",
    "\n",
    "print(near_thousand(300))\n",
    "print(near_thousand(900))\n",
    "print(near_thousand(7000))\n",
    "print(near_thousand(1900))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b87b57bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def add(n, m, p):\n",
    "    if n == m == p:\n",
    "        y = (n+m+p)*3\n",
    "        print(y)\n",
    "    else:\n",
    "        print(n+m+p)\n",
    "\n",
    "print(add(3,3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "324f4118",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "def sum_thrice(x, y, z):\n",
    "\n",
    "     sum = x + y + z\n",
    "  \n",
    "     if x == y == z:\n",
    "      sum = sum * 3\n",
    "     return sum\n",
    "\n",
    "print(sum_thrice(1, 2, 3))\n",
    "print(sum_thrice(3, 3, 3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "551bd3dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IsExcel\n",
      "IsStrange\n"
     ]
    }
   ],
   "source": [
    "def new_str(text):\n",
    "    \n",
    "    if len(text) >= 2 and text[:2] == \"Is\":\n",
    "        return text\n",
    "    return(\"Is\" + text)\n",
    "    \n",
    "print(new_str(\"IsExcel\"))\n",
    "print(new_str(\"Strange\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2f406cfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".test 3\n"
     ]
    }
   ],
   "source": [
    "def copies(string, n):\n",
    "    return string * n\n",
    "\n",
    "print(\".test\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0028a020",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcabc\n",
      ".py.py.py\n"
     ]
    }
   ],
   "source": [
    "def larger_string(text, n):\n",
    "   result = \"\"\n",
    "    for i in range(n):\n",
    "      result = result + text\n",
    "    return result\n",
    "print(larger_string('abc', 2))\n",
    "print(larger_string('.py', 3)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "21c5a573",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number is Odd.\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def odd_even(n):\n",
    "    if n % 2 == 1:\n",
    "        print(\"number is Odd.\")\n",
    "    else:\n",
    "        print(\"number is EVEN.\")\n",
    "    \n",
    "print (odd_even(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7aaf643d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number : 7\n",
      "Odd number\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Enter a number : \"))\n",
    "mod = num % 2\n",
    "if mod == 0:\n",
    "    print(\"Even number\")\n",
    "else:\n",
    "    print(\"Odd number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "37de9ead",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "lst = [1, 4, 6, 7, 4]\n",
    "for i in lst:\n",
    "    if i == 4:\n",
    "        count += 1\n",
    "    \n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0a686600",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ababab\n",
      "aaaa\n"
     ]
    }
   ],
   "source": [
    "def string_copies(s, n):\n",
    "    if len(s) < 2:\n",
    "        return s * n\n",
    "    else:\n",
    "        return s[:2] * n\n",
    "\n",
    "# Test the function\n",
    "print(string_copies('abcdef', 3)) # 'ababab'\n",
    "print(string_copies('a', 4)) # 'aaaa'\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "ec7a8872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_vowel(char):\n",
    "    all_vowels = 'aeiou'\n",
    "    return char in all_vowels\n",
    "print(is_vowel('c'))\n",
    "print(is_vowel('e'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "ca4169a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_group_member(group_data, n):\n",
    "    return n in group_data\n",
    "print(is_group_member([1, 5, 8, 3], 3))\n",
    "print(is_group_member([5, 8, 3], -1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "e361409a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "##\n",
      "###\n",
      "######\n",
      "#####\n"
     ]
    }
   ],
   "source": [
    "def histogram(numbers):\n",
    "    for n in numbers:\n",
    "        print('#' * n)\n",
    "\n",
    "# Test the function\n",
    "histogram([2, 3, 6, 5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "0fe09ffe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15122\n"
     ]
    }
   ],
   "source": [
    "def concatenate_list_data(list):\n",
    "    result= ''\n",
    "    for element in list:\n",
    "        result += str(element)\n",
    "    return result\n",
    "\n",
    "print(concatenate_list_data([1, 5, 12, 2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a7766770",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "386\n",
      "462\n",
      "418\n",
      "344\n",
      "236\n",
      "566\n",
      "978\n",
      "328\n",
      "162\n",
      "758\n",
      "918\n",
      "237\n"
     ]
    }
   ],
   "source": [
    "numbers = [    \n",
    "    386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345, \n",
    "    399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217, \n",
    "    815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717, \n",
    "    958,743, 527\n",
    "    ]\n",
    "\n",
    "for x in numbers:\n",
    "    if x == 237:\n",
    "        print(x)\n",
    "        break;\n",
    "    elif x % 2 == 0:\n",
    "        print(x)\n",
    "\t\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0a876bdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def colors(color_list_1, color_list_2):\n",
    "    return color_list_1 not in color_list_2\n",
    "print(colors(([\"White\", \"Black\", \"Red\"]), ([\"Red\", \"Green\"]) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3a7527ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original set elements:\n",
      "{'White', 'Red', 'Black'}\n",
      "{'Red', 'Green'}\n",
      "\n",
      "Differenct of color_list_1 and color_list_2:\n",
      "{'White', 'Black'}\n",
      "\n",
      "Differenct of color_list_2 and color_list_1:\n",
      "{'Green'}\n"
     ]
    }
   ],
   "source": [
    "color_list_1 = set([\"White\", \"Black\", \"Red\"])\n",
    "color_list_2 = set([\"Red\", \"Green\"])\n",
    "\n",
    "print(\"Original set elements:\")\n",
    "print(color_list_1)\n",
    "print(color_list_2)\n",
    "\n",
    "print(\"\\nDifferenct of color_list_1 and color_list_2:\")\n",
    "print(color_list_1.difference(color_list_2))\n",
    "\n",
    "print(\"\\nDifferenct of color_list_2 and color_list_1:\")\n",
    "print(color_list_2.difference(color_list_1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "96427c2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'White', 'Black'}\n"
     ]
    }
   ],
   "source": [
    "color_list_1 = set([\"White\", \"Black\", \"Red\"])\n",
    "color_list_2 = set([\"Red\", \"Green\"])\n",
    "print(color_list_1 - color_list_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "78dc4a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the base : 20\n",
      "Input the height : 30\n",
      "area =  300.0\n"
     ]
    }
   ],
   "source": [
    "b = int(input(\"Input the base : \"))\n",
    "h = int(input(\"Input the height : \"))\n",
    "\n",
    "area = b*h/2\n",
    "\n",
    "print(\"area = \", area)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5713b8e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of 12 & 17 = 1\n",
      "GCD of 4 & 6 = 2\n",
      "GCD of 336 & 360 = 24\n"
     ]
    }
   ],
   "source": [
    "#Q31\n",
    "def gcd(x, y):\n",
    "    gcd = 1\n",
    "    if x % y == 0:\n",
    "        return y\n",
    "    for k in range(int(y / 2), 0 , -1):\n",
    "        if x % k == 0 and y % k == 0:\n",
    "            gcd = k\n",
    "            break\n",
    "    return gcd\n",
    "\n",
    "print(\"GCD of 12 & 17 =\", gcd(12,17))\n",
    "print(\"GCD of 4 & 6 =\", gcd(4,6))\n",
    "print(\"GCD of 336 & 360 =\", gcd(336, 360))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b705b0ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCD of 336,360\n",
      "24\n",
      "GCD of 12,17\n",
      "1\n",
      "GCD of 4,6\n",
      "2\n",
      "GCD of 24,30,36\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "from math import gcd as _gcd\n",
    "def gcd(nums):\n",
    "    return reduce(_gcd, nums)\n",
    "nums = [336, 360]\n",
    "print(\"GCD of\",','.join(str(e) for e in nums))\n",
    "print(gcd(nums))\n",
    "nums = [12, 17]\n",
    "print(\"GCD of\",','.join(str(e) for e in nums))\n",
    "print(gcd(nums))\n",
    "nums = [4, 6]\n",
    "print(\"GCD of\",','.join(str(e) for e in nums))\n",
    "print(gcd(nums))\n",
    "nums = [24, 30, 36]\n",
    "print(\"GCD of\",','.join(str(e) for e in nums))\n",
    "print(gcd(nums))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "31531308",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5040\n"
     ]
    }
   ],
   "source": [
    "from math import lcm\n",
    "print(lcm(336, 360))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0b6af6e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def sum_3(x,y,z):\n",
    "    if x == y or y == z or z == x:\n",
    "        sum = 0\n",
    "    else:\n",
    "        sum = x+y+z\n",
    "    return sum\n",
    "\n",
    "print(sum_3(2, 1, 2))\n",
    "print(sum_3(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ccb07f66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def test_number5(x, y):\n",
    "    if x == y or abs(x-y) == 5 or (x+y) == 5:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "print(test_number5(7, 2))\n",
    "print(test_number5(3, 2))\n",
    "print(test_number5(2, 2))\n",
    "print(test_number5(7, 3))\n",
    "print(test_number5(27, 53))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ac36d0fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "Inputs must be integers!\n",
      "Inputs must be integers!\n",
      "Inputs must be integers!\n"
     ]
    }
   ],
   "source": [
    "def add_numbers(a, b):\n",
    "    if not (isinstance(a, int) and isinstance(b, int)):\n",
    "        return \"Inputs must be integers!\"\n",
    "    return a + b\n",
    "print(add_numbers(10, 20))\n",
    "print(add_numbers(10, 20.23))\n",
    "print(add_numbers('5', 6))\n",
    "print(add_numbers('5', '6'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f82a4815",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def calculate(x, y):\n",
    "    result = (x + y) * (x + y)\n",
    "    return result\n",
    "\n",
    "# Test the function with x = 2 and y = 3\n",
    "print(calculate(2, 3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b0396c88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12722.79\n"
     ]
    }
   ],
   "source": [
    "amt = 10000\n",
    "int = 3.5\n",
    "years = 7\n",
    "future_value = amt*((1+(0.01*int)) ** years)\n",
    "print(round(future_value,2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "70654929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.324555320336759\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "p1 = [4, 0]\n",
    "p2 = [6, 6]\n",
    "distance = math.sqrt( ((p1[0]-p2[0])**2)+((p1[1]-p2[1])**2) )\n",
    "\n",
    "print(distance)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b225c81d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Q41 Write a Python program to check whether a file exists.\n",
    "import os.path\n",
    "print(os.path.isfile('main.txt'))\n",
    "print(os.path.isfile('main.py'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "50e35a8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import os.path\n",
    "print(os.path.exists('main.txt'))\n",
    "print(os.path.exists('main.py'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "434607d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File found!\n"
     ]
    }
   ],
   "source": [
    "my_file = open('Practice.ipynb')\n",
    "try:\n",
    "    my_file.close()\n",
    "    print(\"File found!\")\n",
    "except FileNotFoundError:\n",
    "    print(\"File not found!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6cf024be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "#Q42\n",
    "# For 32 bit it will return 32 and for 64 bit it will return 64\n",
    "import struct\n",
    "print(struct.calcsize(\"P\") * 8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9d960768",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name of the operating system: nt\n",
      "Name of the OS system: Windows\n",
      "Version of the operating system: 10\n"
     ]
    }
   ],
   "source": [
    "#Q43\n",
    "import platform \n",
    "import os\n",
    "print(\"Name of the operating system:\", os.name)\n",
    "print(\"Name of the OS system:\", platform.system())\n",
    "print(\"Version of the operating system:\",platform.release())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0c00385e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C:\\\\Users\\\\singh\\\\anaconda3', 'C:\\\\Users\\\\singh\\\\anaconda3\\\\lib\\\\site-packages']\n"
     ]
    }
   ],
   "source": [
    "#Q44\n",
    "import site\n",
    "print(site.getsitepackages())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1d85270a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current File Name :  C:\\Users\\singh\\Python_Basic_Exercise(Part-1)\n"
     ]
    }
   ],
   "source": [
    "#Q46\n",
    "import os\n",
    "print(\"Current File Name : \", os.path.realpath(\"Python_Basic_Exercise(Part-1)\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "df66b5bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "#Q47\n",
    "import multiprocessing\n",
    "print(multiprocessing.cpu_count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aae234bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "246.2458\n",
      "246\n"
     ]
    }
   ],
   "source": [
    "#Q48\n",
    "n = \"246.2458\"\n",
    "print(float(n))\n",
    "print(int(float(n)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "59e301fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "^^^^^"
     ]
    }
   ],
   "source": [
    "#Q50\n",
    "i=0\n",
    "while i<5:\n",
    "    print ('^',end='')\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "678e3472",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}