Python Practice Problems Basics (61-80).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9edaec7a",
   "metadata": {},
   "source": [
    "# Python Practice Problems (61-80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d5d972",
   "metadata": {},
   "source": [
    "#### 61. Write a Python program to perform an action if a condition is true.\n",
    "\n",
    "Given a variable name, if the value is 1, display the string \"First day of a Month!\" and do nothing if the value is not equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "844f872a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any number : 1\n",
      "First Day of a Month\n"
     ]
    }
   ],
   "source": [
    "input_var = int(input(\"Enter any number : \"))\n",
    "\n",
    "if input_var==1:\n",
    "    print(\"First Day of a Month\")\n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a9dc1c",
   "metadata": {},
   "source": [
    "#### 62. Write a Python program to swap two variables.\n",
    "\n",
    "Swapping two variables refers to mutually exchanging the values of the variables. Generally, this is done with the data in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "38b8a2a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before swapping numbers:  (5, 10)\n",
      "After swapping numbers:  (10, 5)\n"
     ]
    }
   ],
   "source": [
    "a=5\n",
    "b=10\n",
    "\n",
    "print(\"Before swapping numbers: \", (a,b))\n",
    "\n",
    "a,b = b,a\n",
    "\n",
    "\n",
    "print(\"After swapping numbers: \", (a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "825dc0c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of first variable : 5\n",
      "Enter the value of second varible : 8\n",
      "You have input a = 5 and b = 8\n",
      "After swapping, a = 8 and b = 5\n"
     ]
    }
   ],
   "source": [
    "input_1 = int(input(\"Enter the value of first variable : \"))\n",
    "\n",
    "input_2 = int(input(\"Enter the value of second varible : \"))\n",
    "\n",
    "print(f\"You have input a = {input_1} and b = {input_2}\")\n",
    "\n",
    "input_1,input_2 = input_2,input_1\n",
    "\n",
    "print(f\"After swapping, a = {input_1} and b = {input_2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f5da1f1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of first variable : 5\n",
      "Enter the value of second varible : 8\n",
      "You have input a = 5 and b = 8\n",
      "After swapping, a = 8 and b = 5\n"
     ]
    }
   ],
   "source": [
    "input_1 = int(input(\"Enter the value of first variable : \"))\n",
    "\n",
    "input_2 = int(input(\"Enter the value of second varible : \"))\n",
    "\n",
    "print(f\"You have input a = {input_1} and b = {input_2}\")\n",
    "\n",
    "temp = input_1\n",
    "\n",
    "input_1 = input_2\n",
    "\n",
    "input_2 = temp\n",
    "\n",
    "print(f\"After swapping, a = {input_1} and b = {input_2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bcfacc7",
   "metadata": {},
   "source": [
    "#### 63. Write a Python program to get the Identity, Type, and Value of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2c92b19c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Identity is:  1560195525968\n",
      "Type is:  <class 'int'>\n",
      "Value is:  34\n"
     ]
    }
   ],
   "source": [
    "x = 34\n",
    "\n",
    "print(\"Identity is: \",id(x))\n",
    "print(\"Type is: \",type(x))\n",
    "print(\"Value is: \",x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7874e4d8",
   "metadata": {},
   "source": [
    "#### 64. Write a Python program to convert the bytes in a given string to a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5caf9ff6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : India is great\n",
      "You have entered : India is great\n",
      "Converting bytes of the said string into a list a integers :\n",
      "[73, 110, 100, 105, 97, 32, 105, 115, 32, 103, 114, 101, 97, 116]\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered :\", input_string)\n",
    "\n",
    "list_int =[]\n",
    "\n",
    "print(\"Converting bytes of the said string into a list a integers :\")\n",
    "\n",
    "for char in input_string:\n",
    "    list_int.append(ord(char))\n",
    "    \n",
    "print(list_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3e6e74b",
   "metadata": {},
   "source": [
    "#### 65. Write a Python program to check whether a string is numeric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "612ec87d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word or a number : 5\n",
      "You have entered :  5\n",
      "The input value is a number\n"
     ]
    }
   ],
   "source": [
    "# this wil not work for  float\n",
    "input_user = input(\"Enter a word or a number : \")\n",
    "\n",
    "print(\"You have entered : \", input_user)\n",
    "\n",
    "if input_user.isdigit():\n",
    "    print(\"The input value is a number\")\n",
    "else:\n",
    "    print(\"The input  value is not a number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "741fd205",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word or a number : 5.2\n",
      "You have entered :  5.2\n",
      "The input  value is not a number\n"
     ]
    }
   ],
   "source": [
    "# this wil not work for  float\n",
    "input_user = input(\"Enter a word or a number : \")\n",
    "\n",
    "print(\"You have entered : \", input_user)\n",
    "\n",
    "if input_user.isdecimal():\n",
    "    print(\"The input value is a number\")\n",
    "else:\n",
    "    print(\"The input  value is not a number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c8de0011",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word or a number : 5.2\n",
      "You have entered :  5.2\n",
      "The input  value is not a number\n"
     ]
    }
   ],
   "source": [
    "# this wil not work for  float\n",
    "input_user = input(\"Enter a word or a number : \")\n",
    "\n",
    "print(\"You have entered : \", input_user)\n",
    "\n",
    "if input_user.isnumeric():\n",
    "    print(\"The input value is a number\")\n",
    "else:\n",
    "    print(\"The input  value is not a number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e95dd6e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word or a number : 5.2\n",
      "You have entered :  5.2\n",
      "The input is a number\n"
     ]
    }
   ],
   "source": [
    "input_user = input(\"Enter a word or a number : \")\n",
    "\n",
    "print(\"You have entered : \", input_user)\n",
    "\n",
    "try:\n",
    "    check = float(input_user)\n",
    "    print(\"The input is a number\")\n",
    "except:\n",
    "    print(\"The input is not a number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e87c16c",
   "metadata": {},
   "source": [
    "#### 66. Write a Python program to get system time.\n",
    "\n",
    "The system time is important for debugging, network information, random number seeds, or something as simple as program performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "74a4977c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The system time is:\n",
      " Fri Mar 17 14:02:10 2023\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "print(\"The system time is:\\n\", time.ctime())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "3c7ddd16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The system time is :\n",
      " 2023-03-17 14:02:22.075126\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "print(\"The system time is :\\n\", datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a638110",
   "metadata": {},
   "source": [
    "#### 67. Write a Python program to get numbers divisible by fifteen from a list using an anonymous function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "2a2c7781",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [45, 55, 60, 37, 100, 105, 220]\n",
      "Numbers divisible by 15 are  [45, 60, 105]\n"
     ]
    }
   ],
   "source": [
    "input_list = [45, 55, 60, 37, 100, 105, 220]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "num_divisible_by_15=  list(filter(lambda x: x%15==0,input_list))\n",
    "\n",
    "print(\"Numbers divisible by 15 are \", num_divisible_by_15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "27b18f51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [45, 55, 60, 37, 100, 105, 220]\n",
      "Numbers divisible by 15 are  [45, 60, 105]\n"
     ]
    }
   ],
   "source": [
    "input_list = [45, 55, 60, 37, 100, 105, 220]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "num_divisible_by_15 =[]\n",
    "\n",
    "for num in input_list:\n",
    "    if num%15==0:\n",
    "        num_divisible_by_15.append(num)\n",
    "\n",
    "print(\"Numbers divisible by 15 are \", num_divisible_by_15)      "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b939309",
   "metadata": {},
   "source": [
    "#### 68. Write a Python program to remove the first item from a specified list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b1f1a400",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list elements:\n",
      "['Red', 'Black', 'Green', 'White', 'Orange']\n",
      "After removing the first color:\n",
      "['Black', 'Green', 'White', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "color = [\"Red\", \"Black\", \"Green\", \"White\", \"Orange\"]\n",
    "print(\"Original list elements:\")\n",
    "print(color)\n",
    "\n",
    "# by slicing\n",
    "color = color[1:]\n",
    "\n",
    "print(\"After removing the first color:\")\n",
    "print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "d368c41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list elements:\n",
      "['Red', 'Black', 'Green', 'White', 'Orange']\n",
      "After removing the first color:\n",
      "['Black', 'Green', 'White', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "color = [\"Red\", \"Black\", \"Green\", \"White\", \"Orange\"]\n",
    "print(\"Original list elements:\")\n",
    "print(color)\n",
    "# by using remove\n",
    "color.remove(color[0])\n",
    "\n",
    "print(\"After removing the first color:\")\n",
    "print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "4b1b4650",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list elements:\n",
      "['Red', 'Black', 'Green', 'White', 'Orange']\n",
      "After removing the first color:\n",
      "['Black', 'Green', 'White', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "color = [\"Red\", \"Black\", \"Green\", \"White\", \"Orange\"]\n",
    "print(\"Original list elements:\")\n",
    "print(color)\n",
    "# by using del\n",
    "del color[0]\n",
    "\n",
    "print(\"After removing the first color:\")\n",
    "print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3c37c980",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list elements:\n",
      "['Red', 'Black', 'Green', 'White', 'Orange']\n",
      "After removing the first color:\n",
      "['Black', 'Green', 'White', 'Orange']\n"
     ]
    }
   ],
   "source": [
    "color = [\"Red\", \"Black\", \"Green\", \"White\", \"Orange\"]\n",
    "print(\"Original list elements:\")\n",
    "print(color)\n",
    "# by using pop (by default removes last item from the list)\n",
    "color.pop(0)\n",
    "\n",
    "print(\"After removing the first color:\")\n",
    "print(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10c6e7b",
   "metadata": {},
   "source": [
    "#### 69. Write a Python program that inputs a number and generates an error message if it is not a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "a513c3af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number : 542aa\n",
      "The input is not a number\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    input_user = int(input(\"Enter a number : \"))\n",
    "    print(\"The input is  a number\")\n",
    "except:\n",
    "    print(\"The input is not a number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1dd03db",
   "metadata": {},
   "source": [
    "#### 70. Write a Python program to filter positive numbers from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "aea202ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [34, 1, 0, -23, 12, -88]\n",
      "Positive numbers from the given list are  [34, 1, 12]\n"
     ]
    }
   ],
   "source": [
    "input_list = [34, 1, 0, -23, 12, -88]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "positive_num = list(filter(lambda x:x>0, input_list))\n",
    "\n",
    "print(\"Positive numbers from the given list are \", positive_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "a66bb61b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [34, 1, 0, -23, 12, -88]\n",
      "Positive numbers from the list [34, 1, 12]\n"
     ]
    }
   ],
   "source": [
    "input_list = [34, 1, 0, -23, 12, -88]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "positive_num = []\n",
    "\n",
    "for num in input_list:\n",
    "    if num >0:\n",
    "        positive_num.append(num)\n",
    "    \n",
    "print(\"Positive numbers from the list\", positive_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "0ed30e7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [34, 1, 0, -23, 12, -88]\n",
      "Positive numbers from the list [34, 1, 12]\n"
     ]
    }
   ],
   "source": [
    "input_list = [34, 1, 0, -23, 12, -88]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "positive_num = [num for num in input_list if num >0]\n",
    "\n",
    "print(\"Positive numbers from the list\", positive_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "40b66f6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [34, 1, 0, -23, 12, -88]\n",
      "Positive numbers from the list 34 1 12\n"
     ]
    }
   ],
   "source": [
    "input_list = [34, 1, 0, -23, 12, -88]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "positive_num = [num for num in input_list if num >0]\n",
    "\n",
    "print(\"Positive numbers from the list\", *positive_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af3e5a31",
   "metadata": {},
   "source": [
    "#### 71. Write a Python program to compute the product of a list of integers (without using a for loop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "6e3462a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [10, 20, 30]\n",
      "Product of the said numbers (without using for loop) :  6000\n"
     ]
    }
   ],
   "source": [
    "input_list = [10, 20, 30]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "list_int_product = 1\n",
    "\n",
    "while len(input_list)>0:\n",
    "    list_int_product *= input_list.pop()\n",
    "    \n",
    "print(\"Product of the said numbers (without using for loop) : \", list_int_product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "37b16055",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [10, 20, 30]\n",
      "Product of the said numbers (without using for loop) :  6000\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "input_list = [10, 20, 30]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "list_int_product = reduce((lambda x,y :x*y),input_list)\n",
    "\n",
    "print(\"Product of the said numbers (without using for loop) : \", list_int_product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "58605c8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers in the given list :  [10, 20, 30]\n",
      "Product of the said numbers (without using for loop) :  6000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "input_list = [10, 20, 30]\n",
    "\n",
    "print(\"Numbers in the given list : \", input_list)\n",
    "\n",
    "list_int_product = math.prod(input_list)\n",
    "\n",
    "print(\"Product of the said numbers (without using for loop) : \", list_int_product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06c9a259",
   "metadata": {},
   "source": [
    "#### 72. Write a Python program to prove that two string variables of the same value point to the same memory location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "04e424fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory location of string1 :  1560324519088\n",
      "Memory location of string2 :  1560324519088\n",
      "Memory location of string1 and string2 is same\n"
     ]
    }
   ],
   "source": [
    "string1 =  \"India\"\n",
    "string2 = \"India\"\n",
    "\n",
    "print(\"Memory location of string1 : \",id(string1))\n",
    "\n",
    "print(\"Memory location of string2 : \",id(string2))\n",
    "\n",
    "if id(string1)==id(string2):\n",
    "    print(\"Memory location of string1 and string2 is same\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87bd4d76",
   "metadata": {},
   "source": [
    "#### 73. Write a Python program to round a floating-point number to a specified number of decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "92bfa2bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the decimal number : 126542.3255522654\n",
      "You have entered :  126542.3255522654\n",
      "Enter the number of decimal points :4\n",
      "The round off of 126542.3255522654 upto 4 places is  126542.3256\n"
     ]
    }
   ],
   "source": [
    "input_number = float(input(\"Enter the decimal number : \"))\n",
    "\n",
    "print(\"You have entered : \", input_number)\n",
    "\n",
    "decimal_point = int(input(\"Enter the number of decimal points :\"))\n",
    "\n",
    "print(f\"The round off of {input_number} upto {decimal_point} places is \", round(input_number,decimal_point))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "3346c39a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the decimal number : 325.456975985354\n",
      "You have entered :  325.456975985354\n",
      "The round off of 325.456975985354 upto 3 decimal places is 325.457 \n"
     ]
    }
   ],
   "source": [
    "input_number = float(input(\"Enter the decimal number : \"))\n",
    "\n",
    "print(\"You have entered : \", input_number)\n",
    "\n",
    "\n",
    "print(f\"The round off of {input_number} upto 3 decimal places is {input_number:0.3f} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5423c3e3",
   "metadata": {},
   "source": [
    "#### 74. Write a Python program to format a specified string and limit the length of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "e154413e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : India20202050\n",
      "You have entered :  India20202050\n",
      "Enter the limit upto which you want string : 7\n",
      "Limit the length of the string to 7\n",
      "Here is the updated string for the given string India20202050 after limiting length upto 7:  India20\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered : \", input_string)\n",
    "\n",
    "string_limit = int(input(\"Enter the limit upto which you want string : \"))\n",
    "\n",
    "print(f\"Limit the length of the string to {string_limit}\")\n",
    "\n",
    "string_updated = input_string[:string_limit]\n",
    "\n",
    "print(f\"Here is the updated string for the given string {input_string} after limiting length upto {string_limit}: \", string_updated)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f97d7503",
   "metadata": {},
   "source": [
    "#### 75. Write a Python program to determine if a variable is defined or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "dec2453b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable is defined.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = 1\n",
    "except NameError:\n",
    "    print(\"Variable is not defined....!\")\n",
    "else:\n",
    "    print(\"Variable is defined.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "0081c876",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable is not defined....!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    y\n",
    "except NameError:\n",
    "    print(\"Variable is not defined....!\")\n",
    "else:\n",
    "    print(\"Variable is defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfbfd085",
   "metadata": {},
   "source": [
    "#### 76. Write a Python program to empty a variable without destroying it."
   ]
  },
  {
   "cell_type": "raw",
   "id": "8370edea",
   "metadata": {},
   "source": [
    "Sample data: \n",
    "n=20\n",
    "d = {\"x\":200}\n",
    "\n",
    "Expected Output : \n",
    "0\n",
    "{}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "5545165b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing the variable \n",
      " [100, 200, 300]\n",
      "After emptying the variable without deleting it \n",
      " []\n"
     ]
    }
   ],
   "source": [
    "test = [100,200,300]\n",
    "\n",
    "print(\"Initializing the variable \\n\", test)\n",
    "\n",
    "\n",
    "test = type(test)()\n",
    "print(\"After emptying the variable without deleting it \\n\",test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "b72ebf67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialization of variables......\n",
      "\n",
      "\n",
      "Variable for integer......\n",
      "int_var = 10\n",
      "\n",
      "Variable  for Dictionary.......\n",
      "dict_var = {'x': 200}\n",
      "\n",
      "Variable for list.......\n",
      "list_var = [1, 3, 5]\n",
      "\n",
      "Variable for tupple.......\n",
      "tupple_var = (5, 7, 8)\n",
      "\n",
      "\n",
      "\n",
      "Emptying the variable......\n",
      "\n",
      "\n",
      "Variable for integer emptied......\n",
      "int_var = 0\n",
      "\n",
      "Variable  for Dictionary emptied.......\n",
      "dict_var = {}\n",
      "\n",
      "Variable for list emptied.......\n",
      "list_var = []\n",
      "\n",
      "Variable for tupple emptied.......\n",
      "\n",
      "tupple_var = ()\n"
     ]
    }
   ],
   "source": [
    "print(\"Initialization of variables......\\n\\n\")\n",
    "\n",
    "int_var = 10\n",
    "print(\"Variable for integer......\")\n",
    "print(f\"int_var = {int_var}\\n\")\n",
    "\n",
    "dict_var = {\"x\":200}\n",
    "print(\"Variable  for Dictionary.......\")\n",
    "print(f\"dict_var = {dict_var}\\n\")\n",
    "\n",
    "list_var = [1,3,5]\n",
    "print(\"Variable for list.......\")\n",
    "print(f\"list_var = {list_var}\\n\")\n",
    "\n",
    "tupple_var = (5,7,8)\n",
    "print(\"Variable for tupple.......\")\n",
    "print(f\"tupple_var = {tupple_var}\\n\\n\\n\")\n",
    "\n",
    "print(\"Emptying the variable......\\n\\n\")\n",
    "\n",
    "int_var = type(int_var)()\n",
    "print(\"Variable for integer emptied......\")\n",
    "print(f\"int_var = {int_var}\\n\")\n",
    "\n",
    "dict_var = type(dict_var)()\n",
    "print(\"Variable  for Dictionary emptied.......\")\n",
    "print(f\"dict_var = {dict_var}\\n\")\n",
    "\n",
    "list_var = type(list_var)()\n",
    "print(\"Variable for list emptied.......\")\n",
    "print(f\"list_var = {list_var}\\n\")\n",
    "\n",
    "tupple_var = type(tupple_var)()\n",
    "print(\"Variable for tupple emptied.......\\n\")\n",
    "print(f\"tupple_var = {tupple_var}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "116940ce",
   "metadata": {},
   "source": [
    "#### 77. Write a Python program to check whether multiple variables have the same value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "ae402da5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value for first variable : 20\n",
      "Enter the value for second variable : 20\n",
      "Enter the value for third variable : 20\n",
      "All variables have same value\n",
      "All variables are pointing to same memory address\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Enter the value for first variable : \"))\n",
    "y = int(input(\"Enter the value for second variable : \"))\n",
    "z = int(input(\"Enter the value for third variable : \"))\n",
    "\n",
    "if x==y==z:\n",
    "    print(\"All variables have same value\")\n",
    "else:\n",
    "    print(\"All variables have different values\")\n",
    "    \n",
    "if id(x)==id(y)==id(z):\n",
    "    print(\"All variables are pointing to same memory address\")\n",
    "else:\n",
    "    print(\"All variables are pointing to different memory address\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ce6f185",
   "metadata": {},
   "source": [
    "#### 78. Write a Python program to sum all counts in a collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "cfcf7a29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "nums = [2,2,4,6,6,8,6,10,4]\n",
    "print(len(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "fed5000f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "my_collection = [\n",
    "    {\"name\": \"apple\"},\n",
    "    {\"name\": \"banana\"},\n",
    "    {\"name\": \"orange\"}\n",
    "]\n",
    "\n",
    "print(len(my_collection))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "cc602546",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "my_collection = [\n",
    "    {\"name\": \"apple\", \"count\": 3},\n",
    "    {\"name\": \"banana\", \"count\": 2},\n",
    "    {\"name\": \"orange\", \"count\": 5}\n",
    "]\n",
    "\n",
    "count_sum = sum(item[\"count\"] for item in my_collection)\n",
    "\n",
    "print(count_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9571e54f",
   "metadata": {},
   "source": [
    "#### 79. Write a Python program to check whether lowercase letters exist in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "d8c634ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : AAAaa\n",
      "You have entered :  AAAaa\n",
      "Lowercase letters exist in the string.\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered : \",  input_string)\n",
    "\n",
    "lowercase_check = False\n",
    "\n",
    "for char in input_string:\n",
    "    if char.islower():\n",
    "        lowercase_check =True\n",
    "        break\n",
    "        \n",
    "if lowercase_check==True:\n",
    "    print(\"Lowercase letters exist in the string.\")\n",
    "else:\n",
    "    print(\"Lowercase letters do not exist in the said string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "291914df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : AAAaa\n",
      "You have entered :  AAAaa\n",
      "Lowercase letters exist in the string.\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered : \",  input_string)\n",
    "\n",
    "lowercase_check = any(char.islower() for char in input_string)\n",
    "\n",
    "if lowercase_check==True:\n",
    "    print(\"Lowercase letters exist in the string.\")\n",
    "else:\n",
    "    print(\"Lowercase letters do not exist in the said string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a7e268",
   "metadata": {},
   "source": [
    "#### 80. Write a Python program to add leading zeroes to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "21db78fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter numbers of Zeroes:5\n",
      "Your updated string with right trailing zeroes  12345600000\n",
      "Your updated string with left trailing zeroes  00000123456\n",
      "Your updated string with left and right trailing zeroes  0000012345600000\n"
     ]
    }
   ],
   "source": [
    "input_string ='123456'\n",
    "\n",
    "no_of_zeroes = int(input('Please enter numbers of Zeroes:'))\n",
    "\n",
    "print(\"Your updated string with right trailing zeroes \", input_string+'0'*no_of_zeroes)\n",
    "\n",
    "print(\"Your updated string with left trailing zeroes \", '0'*no_of_zeroes+input_string)\n",
    "\n",
    "print(\"Your updated string with left and right trailing zeroes \", '0'*no_of_zeroes+input_string+'0'*no_of_zeroes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "af128588",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have entered the string :  123456\n",
      "123456\n"
     ]
    }
   ],
   "source": [
    "input_string = '123456'\n",
    "\n",
    "print(\"You have entered the string : \", input_string)\n",
    "\n",
    "#string_zero_right = input_string.rjust(5,'0')\n",
    "\n",
    "input_string = input_string.ljust(5,'0')\n",
    "\n",
    "print(input_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "cbd3f7c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789000\n"
     ]
    }
   ],
   "source": [
    "string = \"123456789\"\n",
    "\n",
    "print(string.ljust(12,'0'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "e4482583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : 123456\n",
      "You have entered the string :  123456\n",
      "Enter the direction of trailing zeroes (right or left) : left\n",
      "You have chosen left direction of trailing zeroes\n",
      "Enter staring point of zeroes (should be greater than 6): 8\n",
      "Here is your updated string :  12345600\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered the string : \", input_string)\n",
    "\n",
    "len_string = len(input_string)\n",
    "\n",
    "zero_direction = input(\"Enter the direction of trailing zeroes (right or left) : \").lower()\n",
    "\n",
    "print(f\"You have chosen {zero_direction} direction of trailing zeroes\")\n",
    "\n",
    "no_of_zeroes = int(input(f\"Enter staring point of zeroes (should be greater than {len_string}): \"))\n",
    "\n",
    "if zero_direction == 'right':\n",
    "    string_updated = input_string.rjust(5,'0')\n",
    "    print(\"Here is your updated string : \", string_updated)\n",
    "else:\n",
    "    string_updated = input_string.ljust(no_of_zeroes,'0')\n",
    "    print(\"Here is your updated string : \", string_updated)"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}