15_March_24_Python_DataTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "444d7207-8346-49ae-829b-6db449d7c269",
   "metadata": {},
   "source": [
    "# TOPIC: String Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c75a83-ffe9-4844-8473-891306cc8b5e",
   "metadata": {},
   "source": [
    "## 1) Write a program to reverse a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf88dbcb-3b5e-4a4e-962f-c041d6c3de48",
   "metadata": {},
   "source": [
    "## Ans 1) \n",
    "\n",
    "### Steps:\n",
    "- Reverse the string using slicing.\n",
    "- Remain the start,end index as empty i.e [::]\n",
    "- Set step/jump to -1. That will start from last element.[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db0203f4-3730-4117-8029-467a4f5679ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given String   :Noorain\n",
      "Reversed String: niarooN \n"
     ]
    }
   ],
   "source": [
    "# lets create a string\n",
    "mystring = \"Noorain\"\n",
    "\n",
    "# slicing it \n",
    "reversed_str = mystring[::-1]\n",
    "\n",
    "# Display the string before and after reversing it\n",
    "print(f\"Given String   :{mystring}\\nReversed String: {reversed_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aff5210-3e47-4fca-a51b-bd6eb041bd18",
   "metadata": {},
   "source": [
    "## 2) Check if a string is a palindrome.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "270cd4cf-6484-41ba-993c-73e4f967d68a",
   "metadata": {},
   "source": [
    "## Ans 2) \n",
    "\n",
    "1) Palindrome String : A string is said to be palindrome if first half of the string is same as the reversed of second half of the string.\n",
    "\n",
    "### Steps:\n",
    "- Take the string from the user\n",
    "- First check the length of the string.\n",
    "- 1) If the length is odd then string is not a palindrome.\n",
    "- 2) If legth is even then executes below steps.\n",
    "- Divide the string into two parts i.e str1 and str2\n",
    "- Reverse the second half of the string i.e str2.\n",
    "- Now compare both of the half of the string.\n",
    "- If both are same,given string is palindrome else not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "346a0b87-c62e-40cc-936f-3c71603c3807",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the string to check, is it palindrome or not? banana\n"
     ]
    }
   ],
   "source": [
    "# 1) Take the string from the user\n",
    "input_str = input(\"Enter the string to check, is it palindrome or not?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1912050d-9951-4ab5-acee-9b02d76650fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2) First check the length of the string.\n",
    "str_len = len(input_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5666e3f2-06c9-4a22-a681-e4c5d927bfac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is not a Palindrome.\n"
     ]
    }
   ],
   "source": [
    "# 3) If the length is odd then string is not a palindrome.\n",
    "# 2) If legth is even then executes below steps.\n",
    "# Divide the string into two parts i.e str1 and str2\n",
    "# Reverse the second half of the string i.e str2.\n",
    "# Now compare both of the half of the string.\n",
    "# If both are same,given string is palindrome else not.\n",
    "\n",
    "if str_len%2 != 0:\n",
    "    print(f\"Given string is not a Palindrome.\")\n",
    "else:\n",
    "    # divide the string into two parts\n",
    "    str1 = input_str[:str_len//2]\n",
    "    str2 = input_str[str_len//2:]\n",
    "    \n",
    "    # reverse the str2 \n",
    "    str2 = str2[::-1]\n",
    "    \n",
    "    # comapre both the string\n",
    "    if str1 == str2:\n",
    "        print(f\"Given string is a Palindrome.\")\n",
    "    else:\n",
    "        print(f\"Given string is not a Palindrome.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2ec4f1e-8c50-4905-b44b-ac6c3e2017fc",
   "metadata": {},
   "source": [
    "## 3) Convert a string to uppercase.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41027c1c-ebe7-4f01-95a1-812f2ab86a6d",
   "metadata": {},
   "source": [
    "## Ans 3) \n",
    "\n",
    "### Steps:\n",
    "- Create a string and store into a variable.\n",
    "- Use the string's uppercase function to conert it into uppercase.\n",
    "- Display both the string given and uppercase converted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c11fe7f-ce1b-4b17-bd49-7cf977f1a67b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : banana\n",
      "Uppercase string: BANANA \n"
     ]
    }
   ],
   "source": [
    "# Create a string and store into a variable.\n",
    "s = \"banana\"\n",
    "# Use the string's uppercase function to conert it into uppercase.\n",
    "uppercase_str = s.upper()\n",
    "# Display both the string given and uppercase converted\n",
    "print(f\"Given string : {s}\\nUppercase string: {uppercase_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31994329-bb60-4d60-af53-04e3dfaf4fe8",
   "metadata": {},
   "source": [
    "## 4) Convert a string to lowercase.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c4f513a-b05f-46a3-bd16-54dc73a8e4bb",
   "metadata": {},
   "source": [
    "## Ans 4) \n",
    "\n",
    "### Steps:\n",
    "- Create a string and store into a variable.\n",
    "- Use the string's lowercase function to convert it into lowercase.\n",
    "- Display both the string given and lowercase converted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "121030c7-6e50-4f90-8361-f78013784c07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : APPLE\n",
      "Uppercase string: apple \n"
     ]
    }
   ],
   "source": [
    "# Create a string and store into a variable.\n",
    "s1 = \"APPLE\"\n",
    "# Use the string's uppercase function to conert it into uppercase.\n",
    "lower_str = s1.lower()\n",
    "# Display both the string given and uppercase converted\n",
    "print(f\"Given string : {s1}\\nUppercase string: {lower_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d5f35c1-150e-4b11-89fc-d43f5b3af14b",
   "metadata": {},
   "source": [
    "## 5) Count the number of vowels in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfb0c4ea-73e2-4783-a1cd-c5a293141270",
   "metadata": {},
   "source": [
    "## Ans 5)\n",
    "\n",
    "1) Task   : Count the number of vowels in the string.\n",
    "2) Input  : String\n",
    "3) Output : Number of vowels present in given string.\n",
    "\n",
    "#### Steps :\n",
    "- Take the input i.e string from the user and store it into a variable.\n",
    "- Initialise a varaible vowel_count (that will count the number of vowels in the string) by 0. \n",
    "- Traverse through the string and check if the character is a vowel or not.\n",
    "- If character is a vowel then increase the count of vowel by 1.\n",
    "- Finally return the number of vowels i.e vowel_count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3fc19894-2944-4e90-8823-197d916a18cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter any string :  noorain\n"
     ]
    }
   ],
   "source": [
    "## Step 1) Take the input string from the user\n",
    "input_str = input(\"Enter any string : \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cc235450-1889-41eb-90e4-9e8812e45aab",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Step 2) Initialise a variable vowel_count by zero\n",
    "vowel_count = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4cbbf384-2036-4aee-ac1e-609db2e5833f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Step 3) Traverse through the string and check if the character is a vowel or not.\n",
    "###        If character is a vowel then increase the count of vowel by 1.  \n",
    "\n",
    "for character in input_str:\n",
    "    if character in ['a','e','i','o','u']:     # search character in list of vowels\n",
    "        vowel_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bcc2f181-a42b-4e3d-8d2b-00c636f144bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of vowels in the string : 4 \n"
     ]
    }
   ],
   "source": [
    "## Step 4) Display the vowel count\n",
    "print(f\"The number of vowels in the string : {vowel_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6840ea3a-f376-4a02-8397-d2c834f192db",
   "metadata": {},
   "source": [
    "## 6) Count the number of consonants in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40b9ad47-6917-4e0e-a4eb-a6c455f51153",
   "metadata": {},
   "source": [
    "## Ans 6)\n",
    "\n",
    "1) Task   : Count the number of Cosonants in a string.\n",
    "2) Input  : String\n",
    "3) Output : Number of Consonants present in given string.\n",
    "4) Formula : Number of Consonants in a string = (number of total characters - number of vowels) => (len of string - number of vowels)\n",
    "\n",
    "#### Steps :\n",
    "- Take the input i.e string from the user and store it into a variable.\n",
    "- Initialise a varaible vowel_count (that will count the number of vowels in the string) by 0. \n",
    "- Traverse through the string and check if the character is a vowel or not.\n",
    "- If character is a vowel then increase the count of vowel by 1.\n",
    "- Finally use the formula to calculate the number of Consonants.\n",
    "- Display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4bfc4058-f924-47b0-be92-41527bbffd32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter any string :  university\n"
     ]
    }
   ],
   "source": [
    "## Step 1) Take the input string from the user\n",
    "input_str1 = input(\"Enter any string : \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7067c193-3a7c-4a83-9374-640deaaac772",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Step 2) Initialise a variable vowel_count by zero\n",
    "vowel_count = 0\n",
    "\n",
    "## Step 3) Traverse through the string and check if the character is a vowel or not.\n",
    "###        If character is a vowel then increase the count of vowel by 1.  \n",
    "\n",
    "for character in input_str1:\n",
    "    if character in ['a','e','i','o','u']:     # search character in list of vowels\n",
    "        vowel_count += 1\n",
    "        \n",
    "num_consonents = len(input_str1) - vowel_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2cd02284-78fa-43c4-bec9-87acdc657dae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of consonents in given string : 6 \n"
     ]
    }
   ],
   "source": [
    "## Step 4) Display the consonents count\n",
    "print(f\"The number of consonents in given string : {num_consonents} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1a901ca-ccac-439c-bfeb-2e4779d43ea4",
   "metadata": {},
   "source": [
    "## 7) Remove all whitespaces from a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5311bdaa-d3b8-4b65-8ce4-c4d7c650e41c",
   "metadata": {},
   "source": [
    "## Ans 7)\n",
    "\n",
    "#### Steps :\n",
    "- Create a string and store it into a variable.\n",
    "- Using string's replace funcrtion, replace all spaces with nothing. i.e ; replace(\" \",\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "26d453f8-86e6-4430-bf4a-ce28d524a0a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : my name is noorain raza\n",
      "Updated string : mynameisnoorainraza \n"
     ]
    }
   ],
   "source": [
    "## create string\n",
    "s2 = \"my name is noorain raza\"\n",
    "## replace spaces with nothing\n",
    "updated_str = s2.replace(\" \",\"\")\n",
    "## diplay both the string\n",
    "print(f\"Given string : {s2}\\nUpdated string : {updated_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c795a6a2-14e5-43c9-b49b-88d5a822c26d",
   "metadata": {},
   "source": [
    "## 8)  Find the length of a string without using the `len()` function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa3c68da-913e-415f-ac37-4b81cf3ad015",
   "metadata": {},
   "source": [
    "## Ans 8)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string\n",
    "- Initialise a counter with 0, that will count the number of characters in string.\n",
    "- Traverse through the string.\n",
    "- Increase the counter by 1\n",
    "- Display the length i.e counter value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c5aa8016-abb5-4c19-91c8-bc01b813f168",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of string is: 12 \n"
     ]
    }
   ],
   "source": [
    "## create a string\n",
    "s4 = 'Data Science'\n",
    "\n",
    "## initialise counter\n",
    "char_count = 0\n",
    "\n",
    "## traverse though the string\n",
    "for char in s4:\n",
    "    char_count+=1\n",
    "    \n",
    "## print length of string\n",
    "print(f\"The length of string is: {char_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7ccf6ff-d373-48ae-9716-b5f26014a7dc",
   "metadata": {},
   "source": [
    "## 9) Check if a string contains a specific word."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aeba2e2-f07b-4144-80f9-b38ab5746e4c",
   "metadata": {},
   "source": [
    "## Ans 9)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string\n",
    "- Search/find the specific word in string using string's find function.\n",
    "- If function return any value greater than 0 that means string contains a specific word.\n",
    "- If function returns -1 that means string does not contain a specific word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "918f9e69-37ce-49d7-b3b1-9a0fa015cdc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String contains a specific word.\n"
     ]
    }
   ],
   "source": [
    "# Take a string\n",
    "s5 = 'My name is noorain raza. I am from uttar pradesh bareilly.'\n",
    "# Search/find the specific word in string using string's find function.\n",
    "if s5.find('bareilly')>0:\n",
    "    print(\"String contains a specific word.\")\n",
    "else:\n",
    "    print(\"String does not contain a specific word.\")\n",
    "    \n",
    "# If function return any value greater than 0 that means string contains a specific word.\n",
    "# If function returns -1 that means string does not contain a specific word."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82606cba-9602-4bcb-aea8-31133d0e7cad",
   "metadata": {},
   "source": [
    "## 10) Replace a word in a string with another word.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24554e8e-ff73-4095-9a17-55c0f642d180",
   "metadata": {},
   "source": [
    "## Ans 10)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Using string's replace function replace a word with another word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0ce10eab-56fd-409e-9f75-9ea4df7effa8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : kal sunday hai, kal meri live class hogi\n",
      "Updted String : aaj sunday hai, aaj meri live class hogi  \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s6 = 'kal sunday hai, kal meri live class hogi'\n",
    "# Using string's replace function replace a word with another word.\n",
    "up_s = s6.replace(\"kal\",\"aaj\")\n",
    "\n",
    "# display both the string\n",
    "print(f\"Given string : {s6}\\nUpdted String : {up_s}  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbd3e82f-a0f2-49c1-a5c7-c1440cbd25b3",
   "metadata": {},
   "source": [
    "## 11) Count the occurrences of a word in a string.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b28ac32-fb36-49ce-a5e6-14a91f6e1a7d",
   "metadata": {},
   "source": [
    "## Ans 11)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Using string's count function count the occurences of a word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "040de6db-294e-49a4-b64f-62e84e8ccd0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The occurences of word is : 2 \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s7 = \"kal sunday hai , kal meri live class hogi\"\n",
    "# Using string's count function count the occurences of a word.\n",
    "word_count = s7.count(\"kal\")\n",
    "# print word counts\n",
    "print(f\"The occurences of word is : {word_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78d44b02-e669-499c-b12f-547056c88ddd",
   "metadata": {},
   "source": [
    "## 12) Find the first occurrence of a word in a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d475e7-1ec1-4aee-bc34-386a8eb712b8",
   "metadata": {},
   "source": [
    "## Ans 12)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Using string's find function, find the first occurences of a word.\n",
    "- Display the index of first occrrence if word present in a string else print word doesn't exists in string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "43a1eb5a-81a7-4382-86a5-e177340f8790",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word doesn't exist in string.\n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s8 = \"kal meri live class hai, attend karoge kya?\"\n",
    "# Using string's find function, find the first occurences of a word.\n",
    "# Display the index of first occrrence if word present in a string else return\n",
    "if s8.find('is') != -1:\n",
    "    print(f\"The first occurrence of Word is present at the index: {s8.find('live')} \")\n",
    "else:\n",
    "    print(f\"Word doesn't exist in string.\")\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49da6a42-bf4f-4bf4-bb61-ef051ca39421",
   "metadata": {},
   "source": [
    "## 13) Find the last occurrence of a word in a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d511d64a-115f-4c94-9670-aac8b8151d1a",
   "metadata": {},
   "source": [
    "## Ans 13)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Using string's rfind function, that takes word/char to be find and returns index if word exists.\n",
    "- Display the index of last occrrence if word present in a string else print word doesn't exists in string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6f9c418e-129a-4242-bd05-83f71664dd7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last occurrence of Word is present at the index: 11 \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s9 = \"my name is name\"\n",
    "# Using string's rfind function, that takes word/char to be find and returns index if word exists.\n",
    "# Display the index of last occrrence if word present in a string else print word doesn't exists in string.\n",
    "if s9.rfind(\"name\") != -1:\n",
    "    print(f\"The last occurrence of Word is present at the index: {s9.rfind('name')} \")\n",
    "else:\n",
    "    print(f\"Word doesn't exist.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "509450d7-55ab-4f39-acc3-81bda5da667d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2ff52aef-ba4a-4e9f-a39d-064ede0b919b",
   "metadata": {},
   "source": [
    "## 14) Split a string into a list of words.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fb26743-ba41-47d2-adcd-5b8d2e84d1b1",
   "metadata": {},
   "source": [
    "## Ans 14)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Use string's split function to convert string of word into list of string words.\n",
    "- Display the given string and list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1349f6a0-e403-4669-a9c9-d00ac72dc3d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string: Hello! This is my python data types assignmnet.\n",
      "List of words: ['Hello!', 'This', 'is', 'my', 'python', 'data', 'types', 'assignmnet.'] \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s10 = \"Hello! This is my python data types assignmnet.\"\n",
    "# Use string's split function to convert string of word into list of string words.\n",
    "word_list = s10.split()\n",
    "# Display the given string and list.\n",
    "print(f\"Given string: {s10}\\nList of words: {word_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8326e088-b10a-4d21-b02c-90ec2e9f5c48",
   "metadata": {},
   "source": [
    "## 15) Join a list of words into a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6193b8bf-ed56-4254-863e-c01792ad2e70",
   "metadata": {},
   "source": [
    "## Ans 15)\n",
    "\n",
    "#### Steps :\n",
    "- create a list of words.\n",
    "- Use join function to convert list of word into string.\n",
    "- Display the list of words and converted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "22267fc1-6952-43d8-aac9-52bc2ce68c2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of words: ['my', 'name', 'is', 'noorain']\n",
      "Converted String : my name is noorain \n"
     ]
    }
   ],
   "source": [
    "# create a list of words.\n",
    "s11_list = ['my','name','is','noorain']\n",
    "# Use join function to convert list of word into string.\n",
    "converted_str = \" \".join(s11_list)\n",
    "# Display the list of words and converted string.\n",
    "print(f\"List of words: {s11_list}\\nConverted String : {converted_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24b6cd03-7ce1-4ba1-95f2-69115155a08f",
   "metadata": {},
   "source": [
    "## 16) Convert a string where words are separated by spaces to one where words are separated by underscores."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1849e0f-d831-4b6e-ba56-543c77b5991c",
   "metadata": {},
   "source": [
    "## Ans 16)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Use replace function to replace 'space' with 'underscore'.\n",
    "- Display the final string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d9d3d3c5-3433-49f8-b3c3-0869a8b0979f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : Believe me, You are unstoppable.\n",
      "Converted String : Believe_me,_You_are_unstoppable. \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s12 = \"Believe me, You are unstoppable.\"\n",
    "# Use replace function to replace 'space' with 'underscore'.\n",
    "updated_s12 = s12.replace(\" \",\"_\")\n",
    "# Display the final string.\n",
    "print(f\"Given string : {s12}\\nConverted String : {updated_s12} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfde876-b5c1-4c1d-acaf-b9cfc354415f",
   "metadata": {},
   "source": [
    "## 17) Check if a string starts with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce03f7e3-2d45-40fb-99dc-92561cc080aa",
   "metadata": {},
   "source": [
    "## Ans 17)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words/phrase.\n",
    "- Use string's stratswith() function to check whether a string starts with specific word or not?\n",
    "- Display yes or no accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "9ed4d249-b5c5-4739-a2b5-83318e7db556",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, string starts with a specific word.\n"
     ]
    }
   ],
   "source": [
    "# create a string of words/phrase.\n",
    "s13 = \"Good Morning everyone!\"\n",
    "# Use find function to check whether a string starts with specific word or not?\n",
    "# Display yes or no accordingly.\n",
    "if s13.startswith(\"Good\"):\n",
    "    print(\"Yes, string starts with a specific word.\")\n",
    "else:\n",
    "    print(\"No, string doesn't start with a specific word.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80462e47-48c2-4627-8536-5797e1f79726",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "329ed1c4-f3d7-4499-a8c6-1a8b12f879fc",
   "metadata": {},
   "source": [
    "## 18) Check if a string ends with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ace7d28-4166-4a39-ac9a-bdfac2c40f51",
   "metadata": {},
   "source": [
    "## Ans 18)\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words/phrase.\n",
    "- Use string's endswith() function to check whether a string ends with specific word or not?\n",
    "- Display yes or no accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "c921ced9-2d21-4dbe-a0e8-42ca437a6c8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, string ends with a specific word.\n"
     ]
    }
   ],
   "source": [
    "# create a string of words/phrase.\n",
    "s14 = \"Good Morning everyone!\"\n",
    "# Use find function to check whether a string starts with specific word or not?\n",
    "# Display yes or no accordingly.\n",
    "if s14.endswith(\"everyone!\"):\n",
    "    print(\"Yes, string ends with a specific word.\")\n",
    "else:\n",
    "    print(\"No, string doesn't end with a specific word.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7cdd7ea-b7c9-435b-86ed-1248cfe1d9be",
   "metadata": {},
   "source": [
    "## 19) Convert a string to title case (e.g., \"hello world\" to \"Hello World\")."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30191d9d-c1d9-4348-8033-d4abcf783436",
   "metadata": {},
   "source": [
    "## Ans 19)\n",
    "\n",
    "1) Title case : in string title() is a function that converts the first letter of each word of string to uppercase.\n",
    "\n",
    "#### Steps :\n",
    "- create a string of words.\n",
    "- Use string's titlecase() function to convert string into title case.\n",
    "- Display the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "1a2e2897-436c-4c94-95f7-daee9942b151",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string:hello world\n",
      "Title Case string: Hello World \n"
     ]
    }
   ],
   "source": [
    "# create a string of words.\n",
    "s15 = \"hello world\"\n",
    "# Use string's titlecase() function to convert string into title case.\n",
    "titlecase_str = s15.title()\n",
    "# Display the string.\n",
    "print(f\"Given string:{s15}\\nTitle Case string: {titlecase_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95de1d33-97e9-4652-ac2a-92d813d3ec4d",
   "metadata": {},
   "source": [
    "## 20) Find the longest word in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "361234ce-c763-4bc4-a6a1-71fb2f4bb4e2",
   "metadata": {},
   "source": [
    "## Ans 20)\n",
    "\n",
    "1) Longest word: A word containing max characters/max length.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Convert string into list.\n",
    "- Traverse through each element/word of the list.\n",
    "- Find the length of each word.\n",
    "- Return the max length word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "711f359f-8e94-478d-9986-596c30429e83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : My name is Noorain Raza\n",
      "Longest word in string is : Noorain  \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s16 = \"My name is Noorain Raza\"\n",
    "# Convert string into list.\n",
    "s16_list = s16.split()\n",
    "\n",
    "# Traverse through each element/word of the list.\n",
    "# initialise max_len and max_len_word\n",
    "max_len = 0\n",
    "max_len_word = ''\n",
    "for word in s16_list:\n",
    "    # Find the length of each word.\n",
    "    if len(word) > max_len:\n",
    "        max_len = len(word)\n",
    "        max_len_word = word\n",
    "\n",
    "# Return the max length word.\n",
    "print(f\"Given string : {s16}\\nLongest word in string is : {max_len_word}  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84ad7d28-279c-4d3a-925e-b00ed9ea67a2",
   "metadata": {},
   "source": [
    "## 21) Find the shortest word in a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8646ce-5e66-4acd-b811-f3f0ab9b2b27",
   "metadata": {},
   "source": [
    "## Ans 21)\n",
    "\n",
    "1) Shortest word: A word containing min characters/min length.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Convert string into list.\n",
    "- Traverse through each element/word of the list.\n",
    "- Find the length of each word.\n",
    "- Return the min length word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cac3ca7b-5d86-40c0-b5c3-8ea106cd2575",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : My name is Noorain Raza\n",
      "Shortest word in string is : My  \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s17 = \"My name is Noorain Raza\"\n",
    "# Convert string into list.\n",
    "s17_list = s17.split()\n",
    "\n",
    "# Traverse through each element/word of the list.\n",
    "# initialise min_len(with very high value) and min_len_word\n",
    "min_len = 999999\n",
    "min_len_word = ''\n",
    "for word in s17_list:\n",
    "    # Find the length of each word.\n",
    "    if len(word) < min_len:\n",
    "        min_len = len(word)\n",
    "        min_len_word = word\n",
    "\n",
    "# Return the max length word.\n",
    "print(f\"Given string : {s17}\\nShortest word in string is : {min_len_word}  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b310f4f9-4ce5-4e55-8cc0-98bbe3764070",
   "metadata": {},
   "source": [
    "## 22) Reverse the order of words in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bb82163-18a6-4c33-8ab9-b0809e9a9f2d",
   "metadata": {},
   "source": [
    "## Ans 22)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Convert string into list.\n",
    "- Using the reversed function, reverse the order of string and concatenate each return word into reversed str to form a string in reversed order of wrods.\n",
    "- print the string in reversed order order of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6c7755dc-fdac-44fb-a7e1-675b530075bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : honesty is the best policy\n",
      "String with reversed order of words : policy best the is honesty \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s18 = \"honesty is the best policy\"\n",
    "\n",
    "# Convert string into list.\n",
    "s18_list = s18.split()\n",
    "\n",
    "# Using the reversed function, reverse the order of string.\n",
    "reversed_str = ''\n",
    "for word in reversed(s18_list):\n",
    "    reversed_str = reversed_str + word +\" \"\n",
    "    \n",
    "# print the string in reversed order\n",
    "print(f\"Given string is : {s18}\\nString with reversed order of words : {reversed_str}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f502558-bc05-4e51-bece-5d48aae0b444",
   "metadata": {},
   "source": [
    "## 23) Check if a string is alphanumeric.## "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a0b4309-14e3-4254-a89f-9dff72a789c5",
   "metadata": {},
   "source": [
    "## Ans 23)\n",
    "\n",
    "1) Alphanumeric string : A string is alpha-numeric if all characters in the string are alpha-numeric. That means :\n",
    "- s1 = \"noorain\" ;  all characters are alphabets. It is alphanumeric.\n",
    "- s2 = \"1234456\" ;  all characters are numeric. It is alphanumeric.\n",
    "- s3 = \"noor1234\" ; some characters are alphabets and some are numeric. It is alphanumeric.\n",
    "- s4 = \"noor@#1234\" ; some characters are alphabets, some are numeric and 2 are special characters. It is not alphanumeric.\n",
    "- NOTE: String contains anything other than alphabets or numeric, will not be alpha-numeric.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Use string's isalnum() function to check whether a string is alphanumeric or not.\n",
    "- If string is alphanumeric print \"string is alphanumeric\" else print \"string is not alphanumeric\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "930dfe86-954d-45a6-b9c7-736beaa04dcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is not alphanumeric.\n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s19 = \"@#noor\"\n",
    "# Use string's alphanum() function to check whether a string is alphanumeric or not.\n",
    "# If string is alphanumeric print \"string is alphanumeric\" else print \"string is not alphanumeric\".\n",
    "if s19.isalnum():\n",
    "    print(f\"Given string is alphanumeric.\")\n",
    "else:\n",
    "    print(f\"Given string is not alphanumeric.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "449c5670-cb9f-48e9-abaf-30fa30e28428",
   "metadata": {},
   "source": [
    "## 24) Extract all digits from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4634b32e-ab54-403e-9ebd-3df33b9eaab6",
   "metadata": {},
   "source": [
    "## Ans 24)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Traverse through string and check each character whether it is digit or not by using string's isdigit() function.\n",
    "- If character is digits, append the digit into a list.\n",
    "- Display the list of extracted digits from string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "83aaf2c8-e60d-47f7-94fe-d1be7774db0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is :abcd1ef34gh10\n",
      "List of extracted digits from list : [1, 3, 4, 1, 0] \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s20 = \"abcd1ef34gh10\"\n",
    "# Traverse through string and check each character whether it is digit or not by using string's isdigit() function.\n",
    "# If character is digits, append the digit into a list.\n",
    "\n",
    "digit_list = []                         # create an empty list to store extracted digits.\n",
    "for char in s20:\n",
    "    if char.isdigit():                  # if it is true then append it.\n",
    "        digit_list.append(int(char))\n",
    "        \n",
    "# Display the list of extracted digits from string.\n",
    "print(f\"Given string is :{s20}\\nList of extracted digits from string : {digit_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e014d42-2043-4453-abc9-e5782ecbb752",
   "metadata": {},
   "source": [
    "## 25) Extract all alphabets from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71cc1c35-fb52-4781-a67c-f1c4611acd67",
   "metadata": {},
   "source": [
    "## Ans 25)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Traverse through string and check each character whether it is alphabet or not by using string's isalpha() function.\n",
    "- If character is alphabet, append the aphabet into an empty string.\n",
    "- Display the final string of extracted alphabets from string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b5292081-66e9-4d05-83e0-e17bac14ac6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is :abcd1ef34gh10\n",
      "List of extracted alphabets from string : a b c d e f g h  \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s21 = \"abcd1ef34gh10\"\n",
    "# Traverse through string and check each character whether it is alphabet or not by using string's isalpha() function.\n",
    "# If character is alphabet, append the aphabet into an empty string.\n",
    "\n",
    "alpha_list = \"\"                         # create an empty string to store extracted alphabets.\n",
    "for char in s21:\n",
    "    if char.isalpha():                  # if it is true then append it.\n",
    "        alpha_list = alpha_list + char + \" \"\n",
    "        \n",
    "# Display the list of extracted digits from string.\n",
    "print(f\"Given string is :{s21}\\nList of extracted alphabets from string : {alpha_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4465bc02-6292-4eae-90af-e04f36a59efd",
   "metadata": {},
   "source": [
    "## 26) Count the number of uppercase letters in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82497485-2dd0-4647-90fa-4fe4683fd91c",
   "metadata": {},
   "source": [
    "## Ans 26)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Initialise a counter to count the number of uppercase letters in a string.\n",
    "- Traverse through string and check each character whether it is uppercase or not by using string's isupper() function.\n",
    "- If character is uppercase, increase the counter value by 1.\n",
    "- Display the counter value i.e number of uppercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "46c55c4d-17f7-480f-9e92-3c4bef6f02fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : UpperCaseString\n",
      "Number of uppercase letters are: 3 \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s22 = \"UpperCaseString\"\n",
    "\n",
    "# Initialise a counter to count the number of uppercase letters in a string.\n",
    "upper_letter_count = 0\n",
    "\n",
    "# Traverse through string and check each character whether it is uppercase or not by using string's isupper() function.\n",
    "# If character is uppercase, increase the counter value by 1.\n",
    "for char in s22:\n",
    "    if char.isupper():\n",
    "        upper_letter_count += 1\n",
    "        \n",
    "# Display the counter value i.e number of uppercase letters in a string.\n",
    "print(f\"Given string is : {s22}\\nNumber of uppercase letters are: {upper_letter_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb7f8d48-9978-4fa1-81d0-a373630a04eb",
   "metadata": {},
   "source": [
    "## 27) Count the number of lowercase letters in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7275788a-8076-4ab1-b679-1e492130060f",
   "metadata": {},
   "source": [
    "## Ans 27)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Initialise a counter to count the number of lowercase letters in a string.\n",
    "- Traverse through string and check each character whether it is lowercase or not by using string's islower() function.\n",
    "- If character is lowercase, increase the counter value by 1.\n",
    "- Display the counter value i.e number of lowercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7f4bbe28-89e4-4eec-b81e-59b4cb62b920",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : UpperCaseString\n",
      "Number of lowercase letters are: 12 \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s23 = \"UpperCaseString\"\n",
    "\n",
    "# Initialise a counter to count the number of lowercase letters in a string.\n",
    "lowercase_letter_count = 0\n",
    "\n",
    "# Traverse through string and check each character whether it is lowercase or not by using string's isupper() function.\n",
    "# If character is lowercase, increase the counter value by 1.\n",
    "for char in s23:\n",
    "    if char.islower():\n",
    "        lowercase_letter_count += 1\n",
    "        \n",
    "# Display the counter value i.e number of lowercase letters in a string.\n",
    "print(f\"Given string is : {s23}\\nNumber of lowercase letters are: {lowercase_letter_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c5a2f6-4107-4fe1-a3ee-24be94ebe441",
   "metadata": {},
   "source": [
    "## 28) Swap the case of each character in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c90b2b-f7ca-4b02-9f89-bda6094716bd",
   "metadata": {},
   "source": [
    "## Ans 28)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Use string's swapcase() function to swap the lowercase letter to uppercase and vice versa.\n",
    "- Display the swapped case string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d56c9c15-95c4-4891-891b-e431a54063cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : This is my String\n",
      "Swaped case string: tHIS IS MY sTRING \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s24 = \"This is my String\"\n",
    "\n",
    "# Use string's swapcase() function to swap the lowercase letter to uppercase and vice versa.\n",
    "swapedcase_str = s24.swapcase()\n",
    "\n",
    "# Display the swapped case string.\n",
    "print(f\"Given string is : {s24}\\nSwaped case string: {swapedcase_str} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91da1eaf-7463-4ed0-b55f-c2edf3e76e2b",
   "metadata": {},
   "source": [
    "## 29) Remove a specific word from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c994d3-108f-4756-9451-c4c6d51b5cb5",
   "metadata": {},
   "source": [
    "## Ans 29)\n",
    "\n",
    "1) Note: String is an immutable data type that means once it is created we can't delete/update/insert any character/word from it.\n",
    "2) To make any changes in string, convert it into mutable data type i,e convert string into list.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Convert string into list i.e immutable to mutable data type and store into a variable\n",
    "- Now remove a specfic word by using list.remove() function, by just passing the word to it.\n",
    "- Convert list to string again and print the final string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "023f1746-4df8-4ea2-b619-9aba54e5284c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : This is my string and i want to remove a specific word\n",
      "String after removing a specific word: This is my string and i want to remove a specific\n"
     ]
    }
   ],
   "source": [
    "# take a string \n",
    "s25 = \"This is my string and i want to remove a specific word\"\n",
    "\n",
    "# convert string into list\n",
    "s25_list = s25.split()\n",
    "\n",
    "# use remove() function and pass a specific word that you want to remove\n",
    "s25_list.remove(\"word\")\n",
    "\n",
    "# Display both the string\n",
    "print(f\"Given string : {s25}\\nString after removing a specific word: {' '.join(s25_list)}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23aee802-7171-44dc-bef3-7edca49ef994",
   "metadata": {},
   "source": [
    "## 30) Check if a string is a valid email address."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a5957e3-9510-4abf-94fa-4e01006575d5",
   "metadata": {},
   "source": [
    "## Ans 30)\n",
    "\n",
    "1) To solve this question we should know the conditions of email to be valid.\n",
    "2) An email contains two parts : prefix (personal info) and suffix (domain) seperated by symbol \"@\".\n",
    "3) As a beginner use validate_email function from email_validator library.\n",
    "\n",
    "#### Steps :\n",
    "- Install email_validator library using command < pip install email_validator >\n",
    "- Import validate_email function from email_validator.\n",
    "- email_validator function takes the email as input and returns the object of email, if it is valid else raise error.\n",
    "- To handle the error, we should use try, except block.\n",
    "- If function returns object then print email is valid else return not valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ae2d3829-d742-4482-881d-5f5945cb6e59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting email_validator\n",
      "  Downloading email_validator-2.1.1-py3-none-any.whl (30 kB)\n",
      "Requirement already satisfied: idna>=2.0.0 in /opt/conda/lib/python3.10/site-packages (from email_validator) (3.4)\n",
      "Collecting dnspython>=2.0.0\n",
      "  Downloading dnspython-2.6.1-py3-none-any.whl (307 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m307.7/307.7 kB\u001b[0m \u001b[31m12.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hInstalling collected packages: dnspython, email_validator\n",
      "Successfully installed dnspython-2.6.1 email_validator-2.1.1\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install email_validator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b2d22689-6281-4746-b07c-1fce09aa5fd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from email_validator import validate_email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "42f69ee2-abdf-4e00-b326-637cebb3842c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given email is not valid.\n"
     ]
    }
   ],
   "source": [
    "email = \"noorain2razagmail.com\"\n",
    "try :\n",
    "    v = validate_email(email)\n",
    "    if email == v[\"email\"]:\n",
    "        print(\"Given email is valid.\")\n",
    "except:\n",
    "    print(\"Given email is not valid.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1efcf49-37f5-449b-95ff-aadf2168c903",
   "metadata": {},
   "source": [
    "## 31)  Extract the username from an email address string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b9fde1d-8b17-484d-80e3-49426c8b56f7",
   "metadata": {},
   "source": [
    "## Ans 31)\n",
    "\n",
    "1) An email contains two parts : prefix (personal info) and suffix (domain) seperated by symbol \"@\".\n",
    "2) To extract the username/prefix, split email by '@'.\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of email address.\n",
    "- Split the string by using split() function and pass the argument as \"@\".\n",
    "- Split function will return the list of two words 1st will be username and 2nd will be domain.\n",
    "- Get the 1st element of list i.e username and display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "83009b23-004b-41fe-a1c2-1580181fe7de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string email address is : noorain2raza@gmail.com\n",
      "Extracted username is : noorain2raza \n"
     ]
    }
   ],
   "source": [
    "# Take a string of email address.\n",
    "s26 = \"noorain2raza@gmail.com\"\n",
    "\n",
    "# Split the string by using split() function and pass the argument as \"@\".\n",
    "email_list = s26.split(\"@\")\n",
    "\n",
    "# Split function will return the list of two words 1st will be username and 2nd will be domain.\n",
    "# Get the 1st element of list i.e username and display it.\n",
    "print(f\"Given string email address is : {s26}\\nExtracted username is : {email_list[0]} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f7a0edd-8587-4712-b136-716f9bffd6fb",
   "metadata": {},
   "source": [
    "## 32)  Extract the domain name from an email address string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbefe1c5-6d40-43af-8997-e9f6fa17eb2b",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Ans 32)\n",
    "\n",
    "1) An email contains two parts : prefix (personal info) and suffix (domain) seperated by symbol \"@\".\n",
    "2) To extract the domain/suffix, split email by '@'.\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of email address.\n",
    "- Split the string by using split() function and pass the argument as \"@\".\n",
    "- Split function will return the list of two words 1st will be username and 2nd will be domain.\n",
    "- Get the 2nd element of list i.e domain and display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e324b520-4ae0-42e1-98c9-59e02f15be18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string email address is : noorain2raza@gmail.com\n",
      "Extracted domain is : gmail.com \n"
     ]
    }
   ],
   "source": [
    "# Take a string of email address.\n",
    "s27 = \"noorain2raza@gmail.com\"\n",
    "\n",
    "# Split the string by using split() function and pass the argument as \"@\".\n",
    "email_list1 = s27.split(\"@\")\n",
    "\n",
    "# Split function will return the list of two words 1st will be username and 2nd will be domain.\n",
    "# Get the 2nd element of list i.e domain and display it.\n",
    "print(f\"Given string email address is : {s27}\\nExtracted domain is : {email_list1[1]} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45b43196-e8d3-4d31-99cf-b0c4e76e5493",
   "metadata": {},
   "source": [
    "## 33)  Replace multiple spaces in a string with a single space."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a964bb-4187-4317-93b9-5114cc1be596",
   "metadata": {},
   "source": [
    "## Ans 33)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string.\n",
    "- Split the string by using split() function and store it in a variable.\n",
    "- Using join function, create the string again, by joining each word/element with \" \" single space.\n",
    "- Display the given and updated string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a5681eac-697b-44bd-bd32-e66fceb83ab2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is :    hello world!    my self noorain     raza      i am good\n",
      "Updated string : hello world! my self noorain raza i am good \n"
     ]
    }
   ],
   "source": [
    "# Take a string.\n",
    "s28 = \"   hello world!    my self noorain     raza      i am good\"\n",
    "\n",
    "# Split the string by using split() function and store it in a variable.\n",
    "s28_list = s28.split()\n",
    "\n",
    "# Using join function, create the string again, by joining each word/element with \" \" single space.\n",
    "# Display the given and updated string.\n",
    "print(f\"Given string is : {s28}\\nUpdated string : {' '.join(s28_list)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee679e4e-86ff-4d29-ada4-957f2200617b",
   "metadata": {},
   "source": [
    "## 34)  Check if a string is a valid URL."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c0468ba-14b1-4d17-a9e4-8a149ed3cf63",
   "metadata": {},
   "source": [
    "## Ans 34)\n",
    "\n",
    "1) A valid URL consists of 3 parts : Protocol,Domain and path.\n",
    "2) For ex- \"https://www.github.com/Noorain-Raza-encoder\" in this URL part before // is a protocol.\n",
    "\n",
    "#### Steps :\n",
    "- Install validators library using command  < pip install validators >\n",
    "- Use url function of validators and pass the string url to validate it.\n",
    "- Validators.url() function returns True if given url is valid else raise error.\n",
    "- If function returns true print, url is valid else print url is not valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "36a5abaf-ab7e-42b8-a67b-c2d48ec01de6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting validators\n",
      "  Downloading validators-0.22.0-py3-none-any.whl (26 kB)\n",
      "Installing collected packages: validators\n",
      "Successfully installed validators-0.22.0\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install validators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5bff34a0-d86f-4ff5-b60d-aea38ec935ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import validators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fb7f47d6-b2df-4d64-84a3-75d55abe22c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string URL is valid.\n"
     ]
    }
   ],
   "source": [
    "s30_url = \"https://www.github.com/Noorain-Raza-encoder\"\n",
    "\n",
    "if validators.url(s30_url):\n",
    "    print(\"Given string URL is valid.\")  \n",
    "else:\n",
    "    print(\"Given string URL is not valid.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64d68895-9b3a-41fc-a527-672eef1aba6b",
   "metadata": {},
   "source": [
    "## 35)  Extract the protocol (http or https) from a URL string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b851bf31-f943-4405-8e69-abfb4a7a82d8",
   "metadata": {},
   "source": [
    "## Ans 35)\n",
    "\n",
    "1) A valid URL consists of 3 parts : Protocol,Domain and path.\n",
    "2) For ex- \"https://www.github.com/Noorain-Raza-encoder\" in this URL part before // is a protocol.\n",
    "3) Taks is to extract this protocol from the string URL.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string URL.\n",
    "- Split the string using string's split function by passing argument ':'\n",
    "- It will return a list of two elements.\n",
    "- 1st element is protocol and 2nd element is other part of the URL.\n",
    "- Print the 1st element of the URL i.e protol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "84be35a4-97bb-4251-a20e-f6d1cf596a4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given URL is : https://www.github.com/Noorain-Raza-encoder\n",
      "Extracted protocol is : https \n"
     ]
    }
   ],
   "source": [
    "# Take the string URL.\n",
    "s31_URL = \"https://www.github.com/Noorain-Raza-encoder\"\n",
    "\n",
    "# Split the string using string's split function by passing argument ':'\n",
    "s31_URL_list = s31_URL.split(':')\n",
    "\n",
    "# It will return a list of two elements.\n",
    "# 1st element is protocol and 2nd element is other part of the URL.\n",
    "# Print the 1st element of the URL i.e protol.\n",
    "print(f\"Given URL is : {s31_URL}\\nExtracted protocol is : {s31_URL_list[0]} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69a1a4eb-e67d-4105-9935-0075f3727bb1",
   "metadata": {},
   "source": [
    "## 36)  Find the frequency of each character in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3d7133d-c490-4419-bf44-e23b3464947d",
   "metadata": {},
   "source": [
    "## Ans 36)\n",
    "\n",
    "1) This task can be done by using hashmap/dictionary.\n",
    "2) Create a dictionary and start adding each character one by one. Here character will act as a key and its frequency will act as value.\n",
    "3) If the character doesn't exist in the dictionary then add it as a key and value as 1.\n",
    "4) If character already exist then update its value i.e increase its value by 1. (that means this character is repeapted)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Create an empty dictionary.\n",
    "- Traverse through the string.\n",
    "- Start adding each character into the dictionary with value 1. (if character is new, if it is already there then increase its frequescy by 1.)\n",
    "- NOTE: As we know that dictionary can't contain duplicate keys.\n",
    "- Print the dictionary by using dictionary function dict.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "17f44c73-7ab1-44e5-8731-4b1a56d39b18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of each character in given string : {s32} is : \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('n', 2), ('o', 2), ('r', 1), ('a', 1), ('i', 1)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take the string.\n",
    "s32 = \"noorain\"\n",
    "\n",
    "# Create an empty dictionary.\n",
    "hash_table = {}\n",
    "\n",
    "# Traverse through the string.\n",
    "# Start adding each character into the dictionary with value 1. (if character is new, if it is already there then increase its frequescy by 1.)\n",
    "for char in s32:\n",
    "    hash_table[char] = 1 + hash_table.get(char,0)\n",
    "    \n",
    "# Print the dictionary by using dictionary function dict.items()\n",
    "print(\"Frequency of each character in given string : {s32} is : \")\n",
    "list(hash_table.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69389eff-d613-4999-80e3-a7937da7fc8d",
   "metadata": {},
   "source": [
    "## 37)  Remove all punctuation from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf7b084-118d-484b-bfe8-c1d4296613ff",
   "metadata": {},
   "source": [
    "## Ans 37) \n",
    "\n",
    "1) Let this is the list of basic punctuations that may be in string:        [\".\",\";\",\":\",\"!\",\"?\",\"/\",\"\\\\\",\",\",\"#\",\"@\",\"$\",\"&\",\")\",\"(\",\"\\\"\",\"-\"]\n",
    "2) Note: we can't remove the any character/word from the string as string is an immutable data type.\n",
    "3) But we can replace the character and update the string.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Traverse through the string.\n",
    "- check whether a character is in punctuation list or not?\n",
    "- If it is then replace it with space or nothing and update the string.\n",
    "- Print the final string after removing all the puctuations from the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bc6e5ee1-2b79-4080-91e3-e1247d01a747",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string with puctuations : Hello!, this is a Full--Stack&&Data##Science@@Pro Course????\n",
      "\n",
      "String after removing punctuations : Hello   this is a Full  Stack  Data  Science  Pro Course    \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s33 = \"Hello!, this is a Full--Stack&&Data##Science@@Pro Course????\"\n",
    "\n",
    "# Create a list of punctuations : \n",
    "punc_list = [\".\",\";\",\":\",\"!\",\"?\",\"/\",\"\\\\\",\",\",\"#\",\"@\",\"$\",\"&\",\")\",\"(\",\"\\\"\",\"-\"]\n",
    "\n",
    "# Display the string before making any changes in it.\n",
    "print(f\"Given string with puctuations : {s33}\")\n",
    "\n",
    "\n",
    "# traverse through the string and check character is in punctuation list or not?    \n",
    "for char in s33 :\n",
    "    if char in punc_list:\n",
    "        s33 = s33.replace(char,' ')\n",
    "        \n",
    "# Display the final string after removing all punctuations\n",
    "print(f\"\\nString after removing punctuations : {s33}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a79a2bbd-0877-4345-9ec0-7a43bec80306",
   "metadata": {},
   "source": [
    "## 38)  Check if a string contains only digits."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "593bf384-cd8e-41f1-a812-7f5c2b380f36",
   "metadata": {},
   "source": [
    "## Ans 38)\n",
    "\n",
    "1) String's isdigit() function return True if all the characters in the string are digits.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Use isdigit() function to check whether a string only contains digits or not.\n",
    "- If function return true that means string contains only digits else no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "87b77dd1-2285-4e9e-9c09-5a01261674c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, Given string contains only digits.\n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s34 = '123'\n",
    "\n",
    "# Use isdigit() function to check whether a string only contains digits or not.\n",
    "# If function return true that means string contains only digits else no.\n",
    "\n",
    "if s34.isdigit():\n",
    "    print(\"Yes, Given string contains only digits.\")\n",
    "else:\n",
    "    print(\"No, Given string doesn't contain only digits.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb321d6-c1ba-48a7-b942-901f999c2a59",
   "metadata": {},
   "source": [
    "## 39)  Check if a string contains only alphabets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f8d38f7-91d1-45e9-bf80-9e9e34e11716",
   "metadata": {},
   "source": [
    "## Ans 39)\n",
    "\n",
    "1) String's isalpha() function return True, if all the characters in the string are alphabets.\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Use isalpha() function to check whether a string only contains alphabets or not.\n",
    "- If function returns true that means string contains only alphabets else no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "eaf2ca60-b74e-478f-a4a2-76ba0d64f521",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No, Given string doesn't contain only alphabets.\n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s35 = 'noor raza'\n",
    "\n",
    "# Use isalpha() function to check whether a string only contains alphabets or not.\n",
    "# If function return true that means string contains only alphabets else no.\n",
    "\n",
    "if s35.isalpha():\n",
    "    print(\"Yes, Given string contains only alphabets.\")\n",
    "else:\n",
    "    print(\"No, Given string doesn't contain only alphabets.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22931683-4526-4fbc-96ea-3dd6c8c6f34b",
   "metadata": {},
   "source": [
    "## 40)  Convert a string to a list of characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5330b1dd-ecd7-4914-a81c-24db777bb122",
   "metadata": {},
   "source": [
    "## Ans 40)\n",
    "\n",
    "#### Steps :\n",
    "- Take the string.\n",
    "- Use string's list() function to convert a string to a list of characters.\n",
    "- Print the list of chacters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "592204d8-bd42-49e6-9cf4-7efd74855745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : NOORAIN\n",
      "List of characters : ['N', 'O', 'O', 'R', 'A', 'I', 'N'] \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "s36 = \"NOORAIN\"\n",
    "\n",
    "# Use string's list() function to convert a string to a list of characters.\n",
    "s36_char_list = list(s36)\n",
    "\n",
    "# Print the list of chacters.\n",
    "print(f\"Given string : {s36}\\nList of characters : {s36_char_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c8d841a-d19a-412c-9191-4f58e3e6dea8",
   "metadata": {},
   "source": [
    "## 41)  Check if two strings are anagrams."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a9ff894-6268-493b-95cd-095c35848237",
   "metadata": {},
   "source": [
    "## Ans 41)\n",
    "\n",
    "1) An anagram string is a rearrangement of the letters of a given string to form another word or phrase, using all the original letters exactly once. For example, \"listen\" and \"silent\" are string anagrams of each other.\n",
    "2) After sorting both the string if we compare them, we can know wether both the strings are same or not ? i.e two strings are anagrams or not?\n",
    "3) But string is an immutable data type, we can't change/sort it once it is created.\n",
    "4) So convert string into list then sort and compare it.\n",
    "\n",
    "\n",
    "#### Steps :\n",
    "- Take two string.\n",
    "- Convert both the strings into list.\n",
    "- Comapre both the list if both are similar then strings are anagram else strings are not anagrams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f96d2511-4695-4281-acf0-e374374f5ade",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, Strings are anagrams.\n"
     ]
    }
   ],
   "source": [
    "# Take two string.\n",
    "s37_1 = \"listen\"\n",
    "s37_2 = \"silent\"\n",
    "\n",
    "# Convert both the strings into list.\n",
    "# Comapre both the list if both are similar then strings are anagram else strings are not anagrams.\n",
    "if list(s37_1).sort() == list(s37_2).sort():\n",
    "    print(\"Yes, Strings are anagrams.\")\n",
    "else:\n",
    "    print(\"No, Strings are not anagrams.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baf481f5-8eb3-46d0-8657-1f46b6dd2bd3",
   "metadata": {},
   "source": [
    "## 42)  Encode a string using a Caesar cipher."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa01f35b-882e-4e3a-b59b-51bd6e4a59d0",
   "metadata": {},
   "source": [
    "## Ans 42)\n",
    "\n",
    "1) The Caesar Cipher, a cryptographic technique used to encrypt(encode) and decrypt(decode) messages.It involves shifting the letters of a message/text/string by a certain number of positions. \n",
    "\n",
    "\n",
    "#### Steps :\n",
    "-  Traverse through the string \n",
    "-  Get the ASCII/numeric/unicode value of char and store it in a variable\n",
    "-  ADD the value to unicode value of char to get the unicode value of shifted character\n",
    "-  Now using the chr() function, get the shifted/new_char by passing new_char/shifter_char unicode value to it.\n",
    "-  Finally append/concatenate this char to empty string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "90a1a8ce-2844-4868-9f1c-ac9b7859e3bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : WORLD\n",
      "Encrypted string : ZRUOG \n"
     ]
    }
   ],
   "source": [
    "s42 = \"WORLD\"\n",
    "shift = 3\n",
    "encrpyt = \"\"\n",
    "for char in s42:\n",
    "    char_unicode = ord(char)\n",
    "\n",
    "    new_char_unicode = char_unicode + shift\n",
    "\n",
    "    new_char = chr(new_char_unicode)\n",
    "\n",
    "    encrpyt = encrpyt + new_char\n",
    "\n",
    "print(f\"Given string : {s42}\\nEncrypted string : {encrpyt} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d5de04-34b0-4ebf-bbd5-f5bf5fde20e7",
   "metadata": {},
   "source": [
    "## 43)  Decode a Caesar cipher encoded string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff72a1e4-7cf2-447c-badb-db61c8a10ea1",
   "metadata": {},
   "source": [
    "## Ans 43)\n",
    "\n",
    "1) The Caesar Cipher, a cryptographic technique used to encrypt(encode) and decrypt(decode) messages.It involves shifting the letters of a message/text/string by a certain number of positions. \n",
    "\n",
    "\n",
    "#### Steps :\n",
    "-  Traverse through the string \n",
    "-  Get the ASCII/numeric/unicode value of char and store it in a variable\n",
    "-  SUBSTRACT the value to unicode value of char to get the unicode value of shifted character\n",
    "-  Now using the chr() function, get the shifted/new_char by passing new_char/shifter_char unicode value to it.\n",
    "-  Finally append/concatenate this char to empty string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4c31878-8168-4cbb-878a-b2de29438717",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : ZRUOG\n",
      "Decrypted string : WORLD \n"
     ]
    }
   ],
   "source": [
    "s43 = \"ZRUOG\"\n",
    "shift = 3\n",
    "decrpyt = \"\"\n",
    "for char in s43:\n",
    "    char_unicode = ord(char)\n",
    "\n",
    "    new_char_unicode = char_unicode - shift\n",
    "\n",
    "    new_char = chr(new_char_unicode)\n",
    "\n",
    "    decrpyt = decrpyt + new_char\n",
    "\n",
    "print(f\"Given string : {s43}\\nDecrypted string : {decrpyt} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eb1d50a-d85c-49ae-b1e4-f97d58078071",
   "metadata": {},
   "source": [
    "## 44)  Find the most frequent word in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60176517-7263-472b-b2ce-cf6c578b6d4a",
   "metadata": {},
   "source": [
    "## Ans 44)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Convert the strings into list.\n",
    "- Traverse through each word of the list and create a hashtable/dictionary for each word as a key and frequency as value.\n",
    "- Once dictionary is created, find the max value from the list values.\n",
    "- Traverse through the dictionary and compare max value with each word value. If value is same then return that key/word as a most frequent word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "923bbea5-3a9e-4dec-9d11-6a7e8d7dbef3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : Rohan is a boy. He is very intelligent \n",
      "The most frequent word in string is : is \n"
     ]
    }
   ],
   "source": [
    "# Take a string.\n",
    "s44 = \"Rohan is a boy. He is very intelligent\"\n",
    "\n",
    "# display the given string\n",
    "print(f\"Given string is : {s44} \")\n",
    "# Convert the strings into list.\n",
    "s44_list = s44.split()\n",
    "\n",
    "# Traverse through each word of the list and create a hashtable/dictionary for each word as a key and frequency as value.\n",
    "s44_dict = {}\n",
    "for word in s44_list:\n",
    "    s44_dict[word] = 1 + s44_dict.get(word,0)\n",
    "    \n",
    "# Once dictionary is created, find the max value from the list values.\n",
    "max_freq = max(list(s44_dict.values()))\n",
    "\n",
    "# Traverse through the dictionary and compare max value with each word value. If value is same then return that key/word as a most frequent word.\n",
    "for key in s44_dict:\n",
    "    if s44_dict[key] == max_freq:\n",
    "        print(f\"The most frequent word in string is : {key} \")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "204d8a08-8040-4745-8c8d-d4dbc2f48e81",
   "metadata": {},
   "source": [
    "## 45)  Find all unique words in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05fe66e3-5ae5-40c0-a8e7-6058cb73310a",
   "metadata": {},
   "source": [
    "## Ans 45)\n",
    "\n",
    "1) A word is called as unique if it occurs only 1 time.That means a word of frequency 1 is called as unique word.\n",
    "2) We can use this concept to create a dictionary of all words and we can create a list of those words whose frequency is 1.\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Convert the strings into list.\n",
    "- Traverse through each word of the list and create a hashtable/dictionary for each word as a key and frequency as value.\n",
    "- Once dictionary is created,traverse through it and create a list of words/keys whose value/frequency is 1.\n",
    "- Print that list of unique words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "6cc10d8a-c10b-4eba-8b7a-efe0604cc0d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : Rohan is a boy. He is very intelligent\n",
      "List of unique words in string : ['Rohan', 'boy.', 'He', 'very', 'intelligent'] \n"
     ]
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s45 = \"Rohan is a boy. He is very intelligent\"\n",
    "\n",
    "# Convert the strings into list.\n",
    "s45_wrod_list = s45.split()\n",
    "\n",
    "# Traverse through each word of the list and create a hashtable/dictionary for each word as a key and frequency as value.\n",
    "s45_dict = {}\n",
    "for word in s45_wrod_list:\n",
    "    s45_dict[word] = 1 + s45_dict.get(word,0)\n",
    "    \n",
    "# Once dictionary is created,traverse through it and create a list of words/keys whose value/frequency is 1.\n",
    "s45_uniq_word_lis = []\n",
    "for key in s45_dict:\n",
    "    if s45_dict[key] == 1 and len(key)!=1:\n",
    "        s45_uniq_word_lis.append(key)\n",
    "        \n",
    "# Print that list of unique words.\n",
    "print(f\"Given string is : {s45}\\nList of unique words in string : {s45_uniq_word_lis} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1ee49f3-26da-440a-8593-dac90d3db54b",
   "metadata": {},
   "source": [
    "## 46)  Count the number of syllables in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001cfc67-aac5-4c6c-80c1-7afe323e462c",
   "metadata": {},
   "source": [
    "## Ans 46)\n",
    "\n",
    "1) Syllable is a part/subtring of a word/string that produces 'vowel sound'.\n",
    "2) As a begginner we can count the number of syllabes by just counting the number of vowels in a word/string.\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Create another string of vowels i.e \"aeiou\"\n",
    "- Initialise a variable named as syllable_count as counter.\n",
    "- Traverse through each character in string and check, character is vowel or not.\n",
    "- If character is vowel then increase the syllable count by 1.\n",
    "- finally print the number of syllables in given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "eb08859d-172a-4e7d-93ed-dd0255d982a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : butter\n",
      "Number of syllables in string : 2 \n"
     ]
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s46 = \"butter\"\n",
    "\n",
    "# Create another string of vowels i.e \"aeiou\"\n",
    "vowel_str = \"aeiou\"\n",
    "\n",
    "# Initialise a variable named as syllable_count as counter.\n",
    "syllable_count = 0\n",
    "\n",
    "# Traverse through each character in string and check, character is vowel or not.\n",
    "# If character is vowel then increase the syllable count by 1.\n",
    "for char in s46:\n",
    "    if char in vowel_str :\n",
    "        syllable_count += 1\n",
    "            \n",
    "# finally print the number of syllables in given string.\n",
    "print(f\"Given string is : {s46}\\nNumber of syllables in string : {syllable_count} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d43f67a-756d-462d-924f-b918d3a42ab6",
   "metadata": {},
   "source": [
    "## 47)  Check if a string contains any special characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c374e743-f33f-4876-be95-1f09a323d5ed",
   "metadata": {},
   "source": [
    "## Ans 47)\n",
    "\n",
    "1) List of some special characters : ['~', ':', \"'\", '+', '[', '\\\\', '@', '^', '{', '%', '(', '-', '\"', '*', '|', ',', '&', '<', '`', '}', '.', '_', '=', ']', '!', '>', ';', '?', '#', '$', ')', '/']\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Create a list of special characters.\n",
    "- Traverse through each character in string and check, character is in list of special character or not?.\n",
    "- If character is in the list then print string contains special characters.\n",
    "- Else string does not contain any special character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "0bbaa1d7-25a7-4054-87b2-5e123c75ce89",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CheckSpeChar(string):\n",
    "    # Create a list of special characters.\n",
    "    spec_char_list = ['~', ':', \"'\", '+', '[', '\\\\', '@', '^', '{', '%', '(', '-', '\"', '*', '|', ',', '&', '<', '`', '}', '.', '_', '=', ']', '!', '>', ';', '?', '#', '$', ')', '/']\n",
    "\n",
    "    # Traverse through each character in string and check, character is in list of special character or not?.\n",
    "    # If character is in the list then print string contains special characters.\n",
    "    for char in string:\n",
    "        if char in spec_char_list:\n",
    "            return print(\"Yes, string contains special character.\")\n",
    "            \n",
    "    return print(\"No, string does not contain any special character.\")\n",
    "    # Else string does not contain any special character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "8442f6ce-0b63-4a1a-b721-69b9b5614898",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, string contains special character.\n"
     ]
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s47 = \"noorain2raz1@33adjhfa.com\"\n",
    "CheckSpeChar(s47)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af714c8f-93a1-4552-9b3e-0ed21df901f1",
   "metadata": {},
   "source": [
    "## 48)  Remove the nth word from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3b318a0-212b-4003-a61c-a997db473ff3",
   "metadata": {},
   "source": [
    "## Ans 48)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Convert string into list.\n",
    "- Remove nth word/element from the list using pop function.\n",
    "- convert back list into string and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "690b6e67-5296-48b0-967c-dc15edeb9b4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : Data Science is very popular now days\n",
      "String after removing 2th word : Data is very popular now days \n"
     ]
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s48 = \"Data Science is very popular now days\"\n",
    "n = 2\n",
    "\n",
    "print(f\"Given string : {s48}\")\n",
    "# Convert string into list.\n",
    "s48_list = s48.split()\n",
    "\n",
    "# Remove nth word/element from the list.\n",
    "s48_list.pop(n-1)\n",
    "\n",
    "# convert back list into string and print it.\n",
    "s48 = \" \".join(s48_list)\n",
    "\n",
    "print(f\"String after removing {n}th word : {s48} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7b8629b-e096-46bb-a26d-4df9ac23b028",
   "metadata": {},
   "source": [
    "## 49)  Insert a word at the nth position in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c43730cc-1c6d-4ef7-a9c9-3d000850df7e",
   "metadata": {},
   "source": [
    "## Ans 49)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words.\n",
    "- Convert string into list.\n",
    "- Insert a word at nth position in list using insert function.\n",
    "- convert back list into string and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "75c6b8b0-ce68-4c9a-894a-2ac55993e98d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : Data is very popular now days\n",
      "String after removing 2th word : Data Science is very popular now days \n"
     ]
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s49 = \"Data is very popular now days\"\n",
    "n = 2\n",
    "\n",
    "print(f\"Given string : {s49}\")\n",
    "# Convert string into list.\n",
    "s49_list = s49.split()\n",
    "\n",
    "# Remove nth word/element from the list.\n",
    "s49_list.insert(n-1,'Science')\n",
    "\n",
    "# convert back list into string and print it.\n",
    "s49 = \" \".join(s49_list)\n",
    "\n",
    "print(f\"String after removing {n}th word : {s49} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a3af1d4-0216-4de7-90c4-236e0ce7d624",
   "metadata": {},
   "source": [
    "## 50)  Convert a CSV string to a list of lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1589f52-d79e-4aaf-b1ae-b9d60c02285f",
   "metadata": {},
   "source": [
    "## Ans 50)\n",
    "\n",
    "#### Steps :\n",
    "- Take a string of words. \n",
    "- Create an empty list to store list elements.\n",
    "- Convert string into list.\n",
    "- Traverse through each word in list and convert it into list then append it to the word list which is a list of list.\n",
    "- Print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9688695d-16c3-415e-a913-898958ec4cb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['name'], ['age'], ['height']]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take a string of words.\n",
    "s50 = \"name,age,height\"\n",
    "\n",
    "# Create an empty list to store list elements.\n",
    "wrod_list = []\n",
    "for word in s50.split(\",\"):\n",
    "    wrod_list.append([word])\n",
    "    \n",
    "wrod_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6363c98-6579-4775-9e42-27c3fb8532e5",
   "metadata": {},
   "source": [
    "# TOPIC: List Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65427cb9-59fd-4898-94b3-92ed91a6f2af",
   "metadata": {},
   "source": [
    "## 1) Create a list with integers from 1 to 10."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e42220f-bdca-4333-90a1-1949d3bbb8db",
   "metadata": {},
   "source": [
    "## Ans 1) \n",
    "\n",
    "- Write all the integers from 1 to 10 inside a pair of bracket seperated by comma and assign it to variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "afed8241-2837-43b4-aec1-decd0ed5c1d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created list is : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "print(f\"Created list is : {list1} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31ebab9-2bd5-49d0-a045-2b38306d4357",
   "metadata": {},
   "source": [
    "## 2)  Find the length of a list without using the `len()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e9cd10-790f-4122-8b8b-a5ff3268034b",
   "metadata": {},
   "source": [
    "## Ans 2)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Initialise a counter with 0, that will count the number of elements in list.\n",
    "- Traverse through the list.\n",
    "- Increase the counter by 1 for each element of the list.\n",
    "- Display the length i.e counter value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6586eb3d-80a3-4e5e-8ea3-99ab8769dc2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Length of list is : 10 \n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list2 = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "# Initialise a counter with 0, that will count the number of elements in list.\n",
    "list_counter = 0\n",
    "\n",
    "# Traverse through the list.\n",
    "# Increase the counter by 1 for each element of the list.\n",
    "for ele in list2:\n",
    "    list_counter += 1\n",
    "    \n",
    "# Display the length i.e counter value. \n",
    "print(f\"Given list : {list2}\\nLength of list is : {list_counter} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8e340ca-4345-4631-a14b-1ca9ef23dada",
   "metadata": {},
   "source": [
    "## 3) Append an element to the end of a list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3024426-094c-4e1e-83f6-9789df8c7c1a",
   "metadata": {},
   "source": [
    "## Ans 3)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Append (add an element at the end of the list) an element by uisng list's append function.\n",
    "- Display the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a278f67-37f4-483a-9a51-7f588ece5a18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 26, 1, 2] \n",
      "Updated list is : [1, 26, 1, 2, 'appended element'] \n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list3 = [1,26,1,2]\n",
    "print(f\"Given list : {list3} \")\n",
    "\n",
    "# Append (add an element at the end of the list) an element by uisng list's append function.\n",
    "list3.append(\"appended element\")\n",
    "\n",
    "# Display the list.\n",
    "print(f\"Updated list is : {list3} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba210a7c-f856-4b42-a6ff-820496bccd7d",
   "metadata": {},
   "source": [
    "## 4) Insert an element at a specific index in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac8c5483-83de-4d33-9ede-199a24465961",
   "metadata": {},
   "source": [
    "## Ans 4)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Insert an element at a specific index in a list by using list's insert function.\n",
    "- Display the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "61901ce4-f566-470f-9c23-247d2ee64e76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [10, 20, 40, 50, 60] \n",
      "Updated list : [10, 20, 'inserted element', 40, 50, 60] \n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list4 = [10,20,40,50,60]\n",
    "\n",
    "print(f\"Given list : {list4} \")\n",
    "\n",
    "# Insert an element at a specific index in a list by using list's insert function.\n",
    "list4.insert(2,\"inserted element\")\n",
    "\n",
    "# Display the list.\n",
    "print(f\"Updated list : {list4} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb4e908-fe55-4ad7-836c-0f598634bb87",
   "metadata": {},
   "source": [
    "## 5) Remove an element from a list by its value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c1ab86-a6f3-4d7e-95a7-96e747ce9d94",
   "metadata": {},
   "source": [
    "## Ans 5)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Remove an element from a list by using list's remove function.\n",
    "- remove function removes the first occurence of the given element from the list.\n",
    "- Display the updated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cec8fb12-5bf6-4957-82ad-eec647619d0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [0, 1, 2, 3, 4, 5, 6] \n",
      "Updated list is : [1, 2, 3, 4, 5, 6] \n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list5 = [0,1,2,3,4,5,6]\n",
    "\n",
    "print(f\"Given list is : {list5} \")\n",
    "\n",
    "# Remove an element from a list by using list's remove function.\n",
    "list5.remove(0)\n",
    "\n",
    "# Display the updated list.\n",
    "print(f\"Updated list is : {list5} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78ae4437-d1ba-4572-a86b-c284344c6527",
   "metadata": {},
   "source": [
    "## 6) Remove an element from a list by its index."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4209fb3c-ca6b-4336-840c-5f65ebcbfb73",
   "metadata": {},
   "source": [
    "## Ans 6)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Remove an element from a list by its index using list's pop function.\n",
    "- Pop function takes index and removes the element from the list.\n",
    "- Display the updated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3b44e4eb-67de-431e-8c17-489f1111906a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 1, 2, 3, 20, 8] \n",
      "Updated list is : [1, 2, 3, 20, 8] \n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list6 = [1,1,2,3,20,8] \n",
    "\n",
    "print(f\"Given list is : {list6} \")\n",
    "\n",
    "# Remove an element from a list by using list's pop function.\n",
    "list6.pop(1)\n",
    "\n",
    "# Display the updated list.\n",
    "print(f\"Updated list is : {list6} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91957f27-5ca5-4df7-83ef-a3e7e6e4ceb2",
   "metadata": {},
   "source": [
    "## 7) Check if an element exists in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb514e44-6b23-401c-ae3d-73263912e78b",
   "metadata": {},
   "source": [
    "## Ans 7)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Traverse through the list lineary and compare the given element with each element of list.\n",
    "- If both elements are same, it means element exists other wise element doesn't exists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3536abf9-97e2-4d70-b4f9-5a78c302616d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [10, 20, 30, 40]\n",
      "Search element : 10 \n",
      "Element exists in list\n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list7 = [10,20,30,40]\n",
    "search_element = 10\n",
    "\n",
    "print(f\"Given list : {list7}\\nSearch element : {search_element} \")\n",
    "# Traverse through the list lineary and compare the given element with each element of list.\n",
    "def seach_element(lis,element):\n",
    "    for ele in list7:\n",
    "        if element == ele:\n",
    "            return print(\"Element exists in list\")\n",
    "\n",
    "    return print(\"Element doesn't exist in list\") \n",
    "# If both elements are same, it means element exists other wise element doesn't exists.\n",
    "seach_element(list7,search_element)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325e1378-ca65-441e-93a9-40a876704e57",
   "metadata": {},
   "source": [
    "## 8) Find the index of the first occurrence of an element in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd69ee2b-069d-4af7-b726-de4f96266ae2",
   "metadata": {},
   "source": [
    "## Ans 8)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list and take an element to find its occurrence\n",
    "- Use index() function to find the first occrurrence of the given element. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bdba3d3c-a0cf-494d-9d36-0b968e9f05fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [2, 5, 5, 6, 7, 8] \n",
      "Index of 1st occurrence of element is : 1\n"
     ]
    }
   ],
   "source": [
    "# create/take a list and take an element to find its occurrence\n",
    "list8 = [2,5,5,6,7,8]\n",
    "element = 5\n",
    "print(f\"Given list : {list8} \")\n",
    "\n",
    "# Use index() function to find the first occrurrence of the given element.\n",
    "print(f\"Index of 1st occurrence of element is : {list8.index(element)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c27cd31-dbd8-412a-8505-20ee6e9e82a9",
   "metadata": {},
   "source": [
    "## 9) Count the occurrences of an element in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9b4edde-d5a2-48ed-91ac-a656a9117727",
   "metadata": {},
   "source": [
    "## Ans 9)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list and take an element to count its occurrence\n",
    "- Use count() function to find the occrurrences of the given element. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bc50290d-2aa7-4a33-995e-dcf5b3f6176f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [2, 5, 5, 6, 7, 8] \n",
      "Occurrence of 5 is : 2\n"
     ]
    }
   ],
   "source": [
    "# create/take a list and take an element to find its occurrence\n",
    "list9 = [2,5,5,6,7,8]\n",
    "element = 5\n",
    "print(f\"Given list : {list9} \")\n",
    "\n",
    "# Use count() function to find the occrurrence of the given element.\n",
    "print(f\"Occurrence of {element} is : {list9.count(element)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9f8a250-0b74-4699-9e7f-a0a30846fe2c",
   "metadata": {},
   "source": [
    "## 10) Reverse the order of elements in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b031ea-3d5c-4d3a-92b9-8f4d8a676ebd",
   "metadata": {},
   "source": [
    "## Ans 10)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Use built-in reversed() function to reverse the elements of list.\n",
    "- Reversed function returns an object of reversed list of elements.\n",
    "- To get all elements traverse through it and append each element into an empty list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b7680ce7-6e07-4dc9-af52-85b2cdb17443",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [4, 5, 6, 7, 8] \n",
      "Reversed of list is : [8, 7, 6, 5, 4]\n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "list10 = [4,5,6,7,8]\n",
    "print(f\"Given list : {list10} \")\n",
    "\n",
    "# Use reversed() function to reversed the elements of list and append each element to new list.\n",
    "reversed_list = []\n",
    "for ele in reversed(list10):\n",
    "    reversed_list.append(ele)\n",
    "    \n",
    "print(f\"Reversed of list is : {reversed_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5054cbc3-95e7-4f2b-a404-3921e335406f",
   "metadata": {},
   "source": [
    "## 11) Sort a list in ascending order."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f241f487-e363-4809-9c6d-04ac323b772e",
   "metadata": {},
   "source": [
    "## Ans 11)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a list.\n",
    "- Use built-in sort() function to sort the elements of list.\n",
    "- Sort function by default sort the elements of list in ascending order\n",
    "- Print the list after sorting the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dbb73fc6-f9d9-41b6-bd64-416f44f8e05f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [2, 90, 7, 5, 6] \n",
      "Sorted list : [2, 5, 6, 7, 90] \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list.\n",
    "list11 = [2,90,7,5,6]\n",
    "\n",
    "# given list\n",
    "print(f\"Given list : {list11} \")\n",
    "\n",
    "#Use built-in sort() function to sort the elements of list.\n",
    "list11.sort()\n",
    "\n",
    "# pirnt the list after sorting the elements\n",
    "print(f\"Sorted list : {list11} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53e06745-bb67-4731-b5ea-e789d09949e5",
   "metadata": {},
   "source": [
    "## 12) Sort a list in descending order"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475e1328-780f-4721-99be-c57640ea20d3",
   "metadata": {},
   "source": [
    "## Ans 12)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a list.\n",
    "- Use built-in sort() function to sort the elements of list.\n",
    "- Pass a parameter reverse = True, that reverse the elements in descending order\n",
    "- Print the list after sorting the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9e7cd43b-df44-4e46-91bb-cfde4162c1bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [2, 90, 7, 5, 6] \n",
      "Sorted list : [90, 7, 6, 5, 2] \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list.\n",
    "list12 = [2,90,7,5,6]\n",
    "\n",
    "# given list\n",
    "print(f\"Given list : {list12} \")\n",
    "\n",
    "#Use built-in sort() function to sort the elements of list.\n",
    "list12.sort(reverse = True)\n",
    "\n",
    "# pirnt the list after sorting the elements\n",
    "print(f\"Sorted list : {list12} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "239220eb-f4b4-4bd2-800b-4d0168ebe538",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 13) Create a list of even numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f725bae-ae08-48ba-b3ca-bbc9d9a00102",
   "metadata": {},
   "source": [
    "## Ans 13)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store all even numbers from 1 to 20.\n",
    "- Generate a sequence of even numbers from 1 to 20 by using range() function.\n",
    "- In range() function, start from 2, take a positive jump of 2 till 21.\n",
    "- Append each number generated from range() function into list.\n",
    "- Print the list of even numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "46799b4e-866d-4dc3-b76a-d4abcde474e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of even numbers from 1 to 20 : [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] \n"
     ]
    }
   ],
   "source": [
    "# Create an empty list\n",
    "list13 = []\n",
    "\n",
    "# Generate a sequence of numbers using range() function and append each generated even number into list\n",
    "# To get only even numbers, start from 2 till 20 and take a jump of 2\n",
    "for i in range(2,21,2):\n",
    "    list13.append(i)\n",
    "    \n",
    "# print list of even numbers\n",
    "print(f\"List of even numbers from 1 to 20 : {list13} \") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fdc9b1c-19b3-4f6d-b058-d89ce9969815",
   "metadata": {},
   "source": [
    "## 14) Create a list of odd numbers from 1 to 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e4a1325-da80-4a26-bb89-4a779b74ef14",
   "metadata": {},
   "source": [
    "## Ans 14)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store all odd numbers from 1 to 20.\n",
    "- Generate a sequence of odd numbers from 1 to 20 by using range() function.\n",
    "- In range() function, start from 1, take a positive jump of 2 till 21.\n",
    "- Append each number generated from range() function into list.\n",
    "- Print the list of odd numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "83f54a40-090d-4706-ae99-c93cc27a96b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of odd numbers from 1 to 20 : [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] \n"
     ]
    }
   ],
   "source": [
    "# Create an empty list\n",
    "list14 = []\n",
    "\n",
    "# Generate a sequence of numbers using range() function and append each generated odd number into list\n",
    "# To get only odd numbers, start from 1 till 20 and take a jump of 2\n",
    "for i in range(1,21,2):\n",
    "    list14.append(i)\n",
    "    \n",
    "# print list of even numbers\n",
    "print(f\"List of odd numbers from 1 to 20 : {list14} \") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d73ae70-584f-40b3-9ef8-ccdfcbc601ef",
   "metadata": {},
   "source": [
    "## 15) Find the sum of all elements in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b30dd8c4-0875-4e06-a8ff-fdae77b4a4f3",
   "metadata": {},
   "source": [
    "## Ans 15)\n",
    "\n",
    "#### Steps:\n",
    "- Create/ take a list from user\n",
    "- use built-in sum() function to summ all the elements \n",
    "- Print the sum of elements of list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7f92e1d3-b9bc-4ec0-9889-00673a61a8b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4] \n",
      "Sum of all the elements of list is : 10 \n"
     ]
    }
   ],
   "source": [
    "# Create/ take a list from user\n",
    "list15 = [1,2,3,4]\n",
    "\n",
    "print(f\"Given list is : {list15} \")\n",
    "# use built-in sum() function to summ all the elements \n",
    "# Print the sum of elements of list\n",
    "\n",
    "print(f\"Sum of all the elements of list is : {sum(list15)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d3375a4-10c0-463e-8b71-428d229a8a50",
   "metadata": {},
   "source": [
    "## 16) Find the maximum value in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51006e6b-d14b-417e-84d5-1fc5b6fe8810",
   "metadata": {},
   "source": [
    "## Ans 16)\n",
    "\n",
    "#### Steps:\n",
    "- Create/ take a list from user\n",
    "- use built-in max() function to find the max value in a list.\n",
    "- Print the max value of list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "34fae249-4c35-40b8-9215-b228c7a58794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4] \n",
      "Max value in a list is : 4 \n"
     ]
    }
   ],
   "source": [
    "# Create/ take a list from user\n",
    "list16 = [1,2,3,4]\n",
    "\n",
    "print(f\"Given list is : {list16} \")\n",
    "# use built-in max() function to find the min value in list.\n",
    "# Print the max value of list\n",
    "\n",
    "print(f\"Max value in a list is : {max(list16)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94373dfb-aeb6-4d6d-af4f-3c37c354528c",
   "metadata": {},
   "source": [
    "## 17) Find the minimum value in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41c9bb2d-973f-4b78-9620-40fad28cb310",
   "metadata": {},
   "source": [
    "## Ans 17)\n",
    "\n",
    "#### Steps:\n",
    "- Create/ take a list from user\n",
    "- use built-in min() function to find the min value in a list.\n",
    "- Print the min value of list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "91151a71-7ee5-4d00-8f1f-9e5e281fc4e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4] \n",
      "Min value in a list is : 1 \n"
     ]
    }
   ],
   "source": [
    "# Create/ take a list from user\n",
    "list16 = [1,2,3,4]\n",
    "\n",
    "print(f\"Given list is : {list16} \")\n",
    "# use built-in min() function to find the min value in list.\n",
    "# Print the min value of list\n",
    "\n",
    "print(f\"Min value in a list is : {min(list16)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f84e1b4-d9d0-4392-a077-6342f276af57",
   "metadata": {},
   "source": [
    "## 18) Create a list of squares of numbers from 1 to 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7609298-3125-4431-a330-d636176b5901",
   "metadata": {},
   "source": [
    "## Ans 18)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store the sqaure of numbers from 1 to 10.\n",
    "- Use range function to generate a sequence of numbers from 1 to 10.\n",
    "- Take the sqaure of each generated number and append it to the list.\n",
    "- Print the list of squares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "72bc13ee-e758-42a9-ac1e-d1b08e31f41d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of squares of numbers from 1 to 10 is : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] \n"
     ]
    }
   ],
   "source": [
    "# Create an empty list to store the sqaure of numbers from 1 to 10.\n",
    "list18 = []\n",
    "\n",
    "# Use range function to generate a sequence of numbers from 1 to 10.\n",
    "# Take the sqaure of each generated number and append it to the list.\n",
    "for i in range(1,11):\n",
    "    list18.append(i*i)\n",
    "    \n",
    "# Print the list of squares.\n",
    "print(f\"List of squares of numbers from 1 to 10 is : {list18} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ed57196-838b-42a1-8458-a32046490236",
   "metadata": {},
   "source": [
    "## 19) Create a list of random numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8777dddc-a82c-4fc5-a57f-259f2f692d68",
   "metadata": {},
   "source": [
    "## Ans 19)\n",
    "\n",
    "#### Steps:\n",
    "- Improt random module to generate a random number from given range.\n",
    "- Create an empty list to store random generated numbers.\n",
    "- Lets create a list of 10 random numbers by running the loop 10 times.\n",
    "- Append each randome generated number to the list.\n",
    "- Print  the random generated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f2d9706e-f1f8-4fad-b04d-47c018694ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "503ae9f6-fde5-41cc-bff5-f53bbe24e03d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 10 random numbers : [2, 11, 16, 17, 18, 11, 5, 13, 14, 17] \n"
     ]
    }
   ],
   "source": [
    "# lets generate a sequence of 10 random numbers\n",
    "list19 = []\n",
    "\n",
    "# run the loop 10 times\n",
    "for i in range(10):\n",
    "    list19.append(random.randrange(1,20))\n",
    "    \n",
    "print(f\"List of 10 random numbers : {list19} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "646892e9-f207-4866-a56b-8f4760c69977",
   "metadata": {},
   "source": [
    "## 20) Remove duplicates from a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b985ac-cbd9-40f3-b692-a1a3ce8182f3",
   "metadata": {},
   "source": [
    "## Ans 20)\n",
    "\n",
    "#### Steps:\n",
    "- Take/create a list of duplicate elements.\n",
    "- Traverse through the list and count the each element occurence.\n",
    "- If the count of any element is greater than 1 that means there is/are duplicate value/s.\n",
    "- To remove duplicate value run the loop number of occurence of element minus 1 times so that we can keep original element.\n",
    "- Print the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4c7ea801-bde2-4206-a69b-f1a1540b7924",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list  : [1, 1, 2, 3, 3, 4, 3, 6] \n",
      "List after removing duplicate values : [1, 2, 4, 3, 6] \n"
     ]
    }
   ],
   "source": [
    "# Take/create a list of duplicate elements.\n",
    "list20 = [1,1,2,3,3,4,3,6]\n",
    "\n",
    "print(f\"Given list  : {list20} \")\n",
    "# Traverse through the list and count the each element occurence.\n",
    "# If the count of any element is greater than 1 that means there is/are duplicate value/s.\n",
    "# To remove duplicate value run the loop number of occurence of element minus 1 times so that we can keep original element.\n",
    "for ele in list20:\n",
    "    if list20.count(ele) > 1:\n",
    "        for i in range(list20.count(ele) -1):\n",
    "            list20.remove(ele)\n",
    "            \n",
    "# Print the list.      \n",
    "print(f\"List after removing duplicate values : {list20} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d87eba-1707-4220-8b46-fa822ad6afff",
   "metadata": {},
   "source": [
    "## 21) Find the common elements between two lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8065beee-623c-43a9-ba81-ee67e51d3c25",
   "metadata": {},
   "source": [
    "## Ans 21)\n",
    "\n",
    "1) We can use set's intersection function to find the common elements between two lists.\n",
    "2) This method handles the duplicate values as well.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two list\n",
    "- Convert both the lists into set.\n",
    "- Use the set's intersection function to get the set of common elements.\n",
    "- Convert common set of elements into list and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "17dc455b-a399-4ff8-a989-cd10506c67d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1 :[1, 2, 3, 4, 5]\n",
      "List 2 : [3, 4, 8, 10, 1]\n",
      "List of Common elements : [1, 3, 4]  \n"
     ]
    }
   ],
   "source": [
    "# Create/take two list\n",
    "list21_1 = [1,2,3,4,5]\n",
    "list21_2 = [3,4,8,10,1]\n",
    "\n",
    "# Convert both the lists into set.\n",
    "# Use the set's intersection function to get the set of common elements.\n",
    "# Convert common set of elements into list and print it.\n",
    "common_elements = list(set(list21_1).intersection(set(list21_2)))\n",
    "\n",
    "print(f\"List 1 :{list21_1}\\nList 2 : {list21_2}\\nList of Common elements : {common_elements}  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9b92ec5-5b5c-46e1-88a3-4dfd91704ca1",
   "metadata": {},
   "source": [
    "## 22) Find the difference between two lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c6fce4-f3c4-4870-8659-3462de392a4e",
   "metadata": {},
   "source": [
    "## Ans 22)\n",
    "\n",
    "1) The difference between two lists is defined as : for ex- list1 = [1,2,9], list2 = [8,7,9]\n",
    "- - The difference between the two lists in Python (first list - second list ) results in items that are in the first list but not in the second list.\n",
    "- - list1 - list2 = [1,2]\n",
    "- - Similarly, the difference between the second list and the first list (second list - first list) results in the items that are in the second list but not in the first list.\n",
    "- - list2 - list1 = [8,7]\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Take/Create two lists\n",
    "- Iterate over the first list using for loop, and for each item in the first list check if the item is present in the second list using the \"not in\" syntax of Python. \n",
    "- If the item is not found in the second list then append the item to a new list(empty list).\n",
    "- Print the difference list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "31f18538-2015-4a84-83e7-bcbae9886b06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1 : [1, 2, 9]\n",
      "List 2 : [8, 7, 9]\n",
      "Difference between list : [1, 2]\n"
     ]
    }
   ],
   "source": [
    "list22_1 = [1,2,9]\n",
    "list22_2 = [8,7,9]\n",
    "\n",
    "# empty list\n",
    "diff_list = []\n",
    "\n",
    "# traverse through \n",
    "for ele1 in list22_1:\n",
    "    if ele1 not in list22_2:\n",
    "        diff_list.append(ele1)\n",
    "       \n",
    "print(f\"List 1 : {list22_1}\\nList 2 : {list22_2}\\nDifference between list : {diff_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25203985-0f36-4321-bcd6-f9c7970a599f",
   "metadata": {},
   "source": [
    "## 23) Merge two lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c1ae9db-e833-410b-93e8-eebfbd4f04dd",
   "metadata": {},
   "source": [
    "## Ans 23)\n",
    "\n",
    "- Take two lists.\n",
    "- Using list concatenation, merge both the list.\n",
    "- Print the merge list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3bce2e9a-bea2-4145-8d1d-74ea48d23f96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1 : [1, 2, 3]\n",
      "List 2 : [4, 5, 6]\n",
      "Merge list : [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "#Take two lists.\n",
    "list23_1 = [1,2,3]\n",
    "list23_2 = [4,5,6]\n",
    "\n",
    "# Using list concatenation, merge both the list.\n",
    "print(f\"List 1 : {list23_1}\\nList 2 : {list23_2}\\nMerge list : {list23_1+list23_2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d10c8a21-e1ab-45db-b974-1003a02e2ac4",
   "metadata": {},
   "source": [
    "## 24) Multiply all elements in a list by 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2634dab8-065f-4b9b-a535-0d3658c81cc9",
   "metadata": {},
   "source": [
    "## Ans 24)\n",
    "\n",
    "- Take a list and create a new list to store multiplied elements.\n",
    "- Traverse through list and multiply each element by 2 and append that element into list.\n",
    "- Print Multiplied list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "bd306cfa-d4eb-4fe3-9d30-35d9dd6cc201",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n",
      "Multiplied each element of list by 2 : [2, 4, 6, 8, 10] \n"
     ]
    }
   ],
   "source": [
    "# Take a list and create a new list to store multiplied elements.\n",
    "list24 = [1,2,3,4,5]\n",
    "list24_1 = []\n",
    "\n",
    "# Traverse through list and multiply each element by 2 and append that element into list.\n",
    "for ele in list24:\n",
    "    list24_1.append(ele*2)\n",
    " \n",
    "# Print Multiplied list.\n",
    "print(f\"Given list : {list24}\\nMultiplied each element of list by 2 : {list24_1} \") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbe0caa1-4f4e-4c9c-8dfb-563ff8ddc056",
   "metadata": {},
   "source": [
    "## 25) Filter out all even numbers from a list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb92054a-3f96-40b3-8ee9-c523b645e787",
   "metadata": {},
   "source": [
    "## Ans 25)\n",
    "\n",
    "1) Task: Create a list of even and odd numbers and extract all the even numbers and them.\n",
    "\n",
    "- Create/take a list from user.\n",
    "- Traverse through list and check whether the element is even or not.\n",
    "- Create a list of even numbers and append all the even numbers into it\n",
    "- Print the even numbers list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ca87f3b3-2f40-4bc0-ad38-09e0eb76076f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "List of filter out even numbers : [2, 4, 6, 8, 10] \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list from user.\n",
    "list25 = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "even_list = []\n",
    "\n",
    "# Traverse through list and check whether the element is even or not.\n",
    "# Create a list of even numbers and append all the even numbers into it\n",
    "for ele in list25:\n",
    "    if ele%2 == 0:\n",
    "        even_list.append(ele)\n",
    "        \n",
    "# Print the even numbers list.\n",
    "print(f\"Given list is : {list25}\\nList of filter out even numbers : {even_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fe7133a-0aa8-49f8-89cf-819460049711",
   "metadata": {},
   "source": [
    "## 26) Convert a list of strings to a list of integers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e902978a-d113-4bf4-b7ee-5866e8eb1b31",
   "metadata": {},
   "source": [
    "## Ans 26) \n",
    "\n",
    "- Create/take a list of string.\n",
    "- Traverse through each string element of list.\n",
    "- Convert each string element into interger by performing typcasting.\n",
    "- And store that element to its place in the list.\n",
    "- Print the updated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9ddc1402-e28b-4d81-a52f-40f5eac5de5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of string : ['1', '2', '10', '7', '9']\n",
      "Updated list : [1, 2, 10, 7, 9] \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of string.\n",
    "list26 = ['1','2','10','7','9']\n",
    "\n",
    "print(f\"Given list of string : {list26}\")\n",
    "# Traverse through each string element of list.\n",
    "# Convert each string element into interger by performing typcasting.\n",
    "# And store that element to its place in the list.\n",
    "for i in  range(len(list26)):\n",
    "    list26[i] = int(list26[i])\n",
    "\n",
    "# Print the updated list.\n",
    "print(f\"Updated list : {list26} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed1dd01-26e5-4a3f-a3c5-f243560cc676",
   "metadata": {},
   "source": [
    "## 27) Convert a list of integers to a list of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe6b5faf-3b88-4738-b1b7-4a89056f6a75",
   "metadata": {},
   "source": [
    "## Ans 27) \n",
    "\n",
    "- Create/take a list of integers.\n",
    "- Traverse through each integer element of list.\n",
    "- Convert each integer element into string by performing typcasting.\n",
    "- And store that element to its place in the list.\n",
    "- Print the updated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8149cb8e-f58f-4cbe-ae41-9ff6e3f604f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of string : [1, 2, 10, 7, 9]\n",
      "Updated list : ['1', '2', '10', '7', '9'] \n"
     ]
    }
   ],
   "source": [
    "# Create/take a list of int.\n",
    "list27 = [1, 2, 10, 7, 9]\n",
    "\n",
    "print(f\"Given list of string : {list27}\")\n",
    "# Traverse through each integer element of list.\n",
    "# Convert each integer element into string by performing typcasting.\n",
    "# And store that element to its place in the list.\n",
    "for i in  range(len(list27)):\n",
    "    list27[i] = str(list27[i])\n",
    "\n",
    "# Print the updated list.\n",
    "print(f\"Updated list : {list27} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe14f07f-03bf-40d9-8d7d-c6db72abe9dd",
   "metadata": {},
   "source": [
    "## 28) Flatten a nested list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3d07d2f-16e8-42c7-9458-478b6cd84f15",
   "metadata": {},
   "source": [
    "## Ans 28) \n",
    "\n",
    "1) Nested list : Lists inside a main list.\n",
    "2) How to identify a list is a nested list?\n",
    "- - Ans : By using type() function we can identify there is a nested list inside the main list or not.\n",
    "3) How to extract the elements of nested list to make the main list flatten after identifying a nested list?\n",
    "- - Ans : First create an empty list and start appending all the elements of the main list , when your code identify there is a nested list, By using the nested loop traverse through the nested list and append each element of nested list to an empty list.\n",
    "\n",
    "\n",
    "#### Steps :\n",
    "- Take/create a nested list.\n",
    "- Create an empty list to store flatten list.\n",
    "- Traverse through the nested list and check the type of each element of the list.\n",
    "- If the type of element is integer then append that element into empty list.\n",
    "- If the type of any element is list, that means there is a nested list, now run a nested loop and traverse through each element of that nested list and append each element to empty list.\n",
    "- Print the flatten list.\n",
    "\n",
    "- NOTE: THIS CODE ONLY WORKS FOR SINGLE NESTED LIST, FOR MULTIPLE NESTED LISTS, WE HAVE TO USE RECURSION FUNCTION."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "93173e7b-62cc-465b-a6d6-e8e2fba980fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested list : [1, 2, 3, [4, 5], 6, 7, [8, 9, 10]]\n",
      "Flatten list : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \n"
     ]
    }
   ],
   "source": [
    "# Take/create a nested list.\n",
    "list28 = [1,2,3,[4,5],6,7,[8,9,10]]\n",
    "\n",
    "# Create an empty list to store flatten list.\n",
    "flatten_list = []\n",
    "\n",
    "# Traverse through the nested list and check the type of each element of the list.\n",
    "# If the type of element is integer then append that element into empty list.\n",
    "# If the type of any element is list, that means there is a nested list, now run a nested loop and traverse through each element of that nested list and append each element to empty list.\n",
    "for ele in list28:\n",
    "    if type(ele) == list:\n",
    "        for list_ele in ele:\n",
    "            flatten_list.append(list_ele)\n",
    "    else:\n",
    "        flatten_list.append(ele)\n",
    "        \n",
    "# Print the flatten list.\n",
    "print(f\"Nested list : {list28}\\nFlatten list : {flatten_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707e201f-147c-4090-aa4f-4beb4ef26af3",
   "metadata": {},
   "source": [
    "## 29) Create a list of the first 10 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a390340c-60a3-4793-86d3-def9f2b24030",
   "metadata": {},
   "source": [
    "## Ans 29)\n",
    "\n",
    "1) Fibonacci series formula : F(n) = F(n-1) + F(n-2)\n",
    "\n",
    "#### Steps :\n",
    "- Initialise a fibonacci series by first two numbers 0 and 1.\n",
    "- Generate a fibonacci series of 10 numbers using fibonacci formula and append next generated element to list.\n",
    "- Print the final fibonaccci series of 10 numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9db2b091-70b7-4046-a529-66a1196a6182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 10 fibonacci numbers is : [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] \n"
     ]
    }
   ],
   "source": [
    "# Initialise a fibonacci series by first two numbers 0 and 1.\n",
    "list29_fibo_num = [0,1]\n",
    "\n",
    "# Generate a fibonacci series of 10 numbers using fibonacci formula and append next generated element to list.\n",
    "for i in range(2,10):\n",
    "    list29_fibo_num.append(list29_fibo_num[i-1] + list29_fibo_num[i-2])\n",
    "    \n",
    "# print the final fibonaccci series of 10 numbers.\n",
    "print(f\"List of 10 fibonacci numbers is : {list29_fibo_num} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "813d94c6-7be1-47e0-bab5-b88f9fcbdd06",
   "metadata": {},
   "source": [
    "## 30) Check if a list is sorted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce2233c6-a375-4433-8e63-ca652ea0f3e4",
   "metadata": {},
   "source": [
    "## Ans 30)\n",
    "\n",
    "1) This function is created to check a list is sorted or not in asceding order.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of elements.\n",
    "- Create a function that only checks whether current element is greater than the next element or not\n",
    "- If current element is greater than next element that means list is not sorted in asceding order.\n",
    "- Else list is sorted in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "00aaf650-9b44-45be-8b9b-0d8497fdb1b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CheckSorting(lis):\n",
    "    for i in range(len(lis)-1):\n",
    "        if lis[i] > lis[i+1]:\n",
    "            return print(\"Given list is not sorted.\")\n",
    "    return print(f\"Given list is sorted\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5dadeb61-2488-4764-bf9c-026061440eac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4, 5, 6] \n",
      "Given list is sorted\n"
     ]
    }
   ],
   "source": [
    "#create a list of elements\n",
    "list30 = [1,2,3,4,5,6]\n",
    "\n",
    "print(f\"Given list is : {list30} \")\n",
    "# call CheckSorting fucntion to check list is sorted or not?\n",
    "CheckSorting(list30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c96cda19-f64e-407f-a968-597f4c767536",
   "metadata": {},
   "source": [
    "## 31) Rotate a list to the left by `n` positions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c63f05ba-15b6-4d8e-bf34-50e42d4972ca",
   "metadata": {},
   "source": [
    "## Ans 31)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of elements.\n",
    "- Take the value of n from user.\n",
    "- Store first element to temp varaible.\n",
    "- Start shifting the value of list from 2nd element till last.\n",
    "- Once shifting is done, assign the temp value to last index.\n",
    "- Repeat the above steps till n times to rotate the elements of list by n position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "81c0e605-8024-48bc-b599-75f9f1dbc649",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n to rotate a list by n positions:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after rotating the elements to the left by 2 position : [3, 4, 5, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "list31 = [1,2,3,4,5]\n",
    "\n",
    "print(f\"Given list : {list31}\")\n",
    "n = int(input(\"Enter value of n to rotate a list by n positions: \"))\n",
    "if n < len(list31):\n",
    "    for i in range(n):\n",
    "        temp = list31[0]\n",
    "        for j in range(1,len(list31)):\n",
    "            list31[j-1] = list31[j]\n",
    "            \n",
    "        list31[-1] = temp\n",
    "else:\n",
    "    for i in range(n%len(list31)):\n",
    "        temp = list31[0]\n",
    "        for j in range(1,len(list31)):\n",
    "            list31[j-1] = list31[j]\n",
    "            \n",
    "        list31[-1] = temp\n",
    "        \n",
    "print(f\"List after rotating the elements to the left by {n} position : {list31}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "436fd39c-6fbe-45b7-a4a7-8ce9b876af40",
   "metadata": {},
   "source": [
    "## 32) Rotate a list to the right by `n` positions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3037cf-64ea-489d-ba9b-664fcef2745a",
   "metadata": {},
   "source": [
    "## Ans 32)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of elements.\n",
    "- Take the value of n from user.\n",
    "- Store last element to temp varaible.\n",
    "- Start shifting the value of list from 2nd last element till start in reverse order.\n",
    "- Once shifting is done, assign the temp value to first index.\n",
    "- Repeat the above steps till n times to rotate the elements of list by n position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d2177685-0098-40fd-9adc-f922e29dc614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n to rotate a list by n positions:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after rotating the elements to the right by 4 position : [2, 3, 4, 5, 1]\n"
     ]
    }
   ],
   "source": [
    "list31 = [1,2,3,4,5]\n",
    "\n",
    "print(f\"Given list : {list31}\")\n",
    "n = int(input(\"Enter value of n to rotate a list by n positions: \"))\n",
    "if n < len(list31):\n",
    "    for i in range(n):\n",
    "        temp = list31[-1]\n",
    "        for j in reversed(range(len(list31))):\n",
    "            list31[j] = list31[j-1]\n",
    "            \n",
    "        list31[0] = temp\n",
    "else:\n",
    "    for i in range(n%len(list31)):\n",
    "        temp = list31[-1]\n",
    "        for j in reversed(range(len(list31))):\n",
    "            list31[j] = list31[j-1]\n",
    "            \n",
    "        list31[0] = temp\n",
    "        \n",
    "print(f\"List after rotating the elements to the right by {n} position : {list31}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eb1dc45-aeed-4597-96f4-3bd2480a1929",
   "metadata": {},
   "source": [
    "## 33) Create a list of prime numbers up to 50."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b64da18a-7d59-41a6-b5ef-01f97e7f3dfd",
   "metadata": {},
   "source": [
    "## Ans 33)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store prime numbers\n",
    "- Run the loop from 2 to 51 to generate prime numbers\n",
    "- Check whether number is prime or not.\n",
    "- If number is prime then append it.\n",
    "- Print the list of prime numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "89605124-af97-4800-b16d-6041fd173903",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime numbers : [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47] \n"
     ]
    }
   ],
   "source": [
    "# create an empty list to store prime numbers\n",
    "prime_list = []\n",
    "\n",
    "# Run the loop from 2 to 51 to generate prime numbers\n",
    "# check whether number is prime or not.\n",
    "# if number is prime then append it.\n",
    "for i in range(2,51):\n",
    "    for j in range(2,i):\n",
    "        if i%j == 0:\n",
    "            break\n",
    "    else:\n",
    "        prime_list.append(i)\n",
    "    \n",
    "# print the list of prime numbers\n",
    "print(f\"List of prime numbers : {prime_list} \")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc621720-eb6c-48d2-add5-e9bc861c412d",
   "metadata": {},
   "source": [
    "## 34) Split a list into chunks of size `n`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0f17f4e-32d4-48f2-839e-00ddaaf41aec",
   "metadata": {},
   "source": [
    "## Ans 34)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of elements and take the size of chunks n from user.\n",
    "- Create an empty list to store chunks.\n",
    "- Run the loop only when chunk size is less than length of list.\n",
    "- Initialise start pointer with 0 and stop pointer with chunk size.\n",
    "- When length%chunks == 0, Run the loop till length/chunks times.- When length%chunks == 0, Run the loop till length/chunks times.\n",
    "- only slice when stop pointer under the range of list.\n",
    "- When length%chunks != 0, Run the loop till length/chunks times and also append the rest of the elements.\n",
    "- Print the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c3ce0c73-5fe9-4a4f-9982-b8c41b52cef8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4, 5, 6, 7, 8, 9] \n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the chunk size to split a list into chunks :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of chunks is : [[1, 2, 3, 4, 5], [6, 7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of elements\n",
    "list34 = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "# print the list:\n",
    "print(f\"Given list is : {list34} \")\n",
    "\n",
    "n = int(input(\"Enter the chunk size to split a list into chunks : \"))\n",
    "\n",
    "# create en empty list to store the chunks \n",
    "temp = []\n",
    "\n",
    "# We only can split a list into chunks when chunk size is less than length of list.\n",
    "# initialise start and stop pointer to slice the list\n",
    "if n < len(list34):\n",
    "    start , stop = 0 , n\n",
    "    \n",
    "    for i in range(int(len(list34)/n)):      # run the loop till length/chunks times\n",
    "        if stop < len(list34):               # only slice when stop pointer under the range of list\n",
    "            temp.append(list34[start:stop])  # append the chunk into temp list\n",
    "            start = stop                     # update both pointers after appending the chunk\n",
    "            stop += n\n",
    "        else:                                \n",
    "            temp.append(list34[start:])      # when stop pointer goes out of range of list\n",
    "    \n",
    "    if len(list34)%n != 0 :                  # appending remaining chunks\n",
    "        temp.append(list34[start:])\n",
    "        \n",
    "                \n",
    "# print the list of chunks\n",
    "print(f\"List of chunks is : {temp}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466c3948-a01d-4a24-80c4-81316d6fd1c2",
   "metadata": {},
   "source": [
    "## 35) Find the second largest number in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5acab3a-01b9-4e84-8d53-00f9de1004d2",
   "metadata": {},
   "source": [
    "## Ans 35)\n",
    "\n",
    "#### Steps:\n",
    "- Take list of elements.\n",
    "- Sort the list of elments in ascending order.\n",
    "- After sorting in ascending order last(-1) element will be largest and hence 2nd last(-2) will be 2nd largest number in a list.\n",
    "- Read the 2nd last elment i.e -2th element from the list and print it as a second largest number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "476891dd-fd3b-4592-9f43-f646dbaf4d57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [10, 30, 50, 100] \n",
      "Second largest number is : 50 \n"
     ]
    }
   ],
   "source": [
    "# Create a list of elements\n",
    "list35 = [10,30,50,100]\n",
    "\n",
    "print(f\"Given list is : {list35} \")\n",
    "\n",
    "# sort the list in ascending order\n",
    "list35.sort()\n",
    "\n",
    "# Read the 2nd last element from the list as 2nd largest number\n",
    "print(f\"Second largest number is : {list35[-2]} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91e70675-847a-4dfc-a105-c1a151f72dbe",
   "metadata": {},
   "source": [
    "## 36) Replace every element in a list with its square."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1b06fe7b-18d7-47e4-934f-2729bd3d20d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of elements is : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \n",
      "List of replaced element with its sqaure : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "# create a list of elements\n",
    "list36 = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "print(f\"Given list of elements is : {list36} \")\n",
    "\n",
    "for i in range(len(list36)):\n",
    "    list36[i] = list36[i]*list36[i]\n",
    "    \n",
    "print(f\"List of replaced element with its sqaure : {list36}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bb15b41-5532-45fb-984d-463a3e241418",
   "metadata": {},
   "source": [
    "## 37) Convert a list to a dictionary where list elements become keys and their indices become values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d6b289-bffb-4f47-b203-31b495c0337e",
   "metadata": {},
   "source": [
    "## Ans 37)\n",
    "\n",
    "#### Steps :\n",
    "- Create a list and empty dictionary.\n",
    "- Using enumerate function get the value and index of list element.\n",
    "- Add index as a value and element as a key into the dictionary.\n",
    "- Print final dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "299cefac-ecfd-4c34-b55d-ca9f8548098d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [10, 20, 30, 40]\n",
      "Converted Dictionary is : {10: 0, 20: 1, 30: 2, 40: 3} \n"
     ]
    }
   ],
   "source": [
    "# Creat/take a list \n",
    "list37 = [10,20,30,40]\n",
    "\n",
    "# create an empty dictionary\n",
    "list_dict = {}\n",
    "\n",
    "# Get the element and index of list element using enumerate fucntion.\n",
    "# add each element as a key and index as a pair into the dictionary\n",
    "for idx,ele in enumerate(list37):\n",
    "    list_dict[ele] = idx\n",
    "\n",
    "# Display dictionary\n",
    "print(f\"Given list is : {list37}\\nConverted Dictionary is : {list_dict} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa9075b-877d-4355-bc13-8a0648b2b0d8",
   "metadata": {},
   "source": [
    "## 38) Shuffle the elements of a list randomly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec3b2bb-5c8e-414d-8870-241235b56e00",
   "metadata": {},
   "source": [
    "## Ans 38)\n",
    "\n",
    "1) Shufle the elements of a list randomly by using shuffle function of random library.\n",
    "2) Shuffle function takes a sequence and rearrange it, it doesn't return anything.\n",
    "\n",
    "#### Steps:\n",
    "- Import random library\n",
    "- Create a list of elements.\n",
    "- Pass a list to shuffle function.\n",
    "- Print the shuffled list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9e80e937-be28-4b56-a1db-6bfa187f105e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n",
      "Shuffled list : [5, 3, 1, 4, 2] \n"
     ]
    }
   ],
   "source": [
    "# import random library\n",
    "import random\n",
    "\n",
    "# create a list of elements\n",
    "list38 = [1,2,3,4,5]\n",
    "\n",
    "print(f\"Given list : {list38}\")\n",
    "# use shuffle function of random library\n",
    "random.shuffle(list38)\n",
    "\n",
    "# print the shuffled list\n",
    "print(f\"Shuffled list : {list38} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c6bb0d-f35c-4bf0-bba5-e1f569a9f40f",
   "metadata": {},
   "source": [
    "## 39) Create a list of the first 10 factorial numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df467e3a-0801-487c-a165-9cf1bf226ecb",
   "metadata": {},
   "source": [
    "## Ans 39)\n",
    "\n",
    "1) Factorial => F(n) = n*F(n-1)\n",
    "2) Base case => F(0) = F(1) = 1\n",
    "\n",
    "#### Steps:\n",
    "- Inititalise a list of factorial by starting 3 number's(0,1,2) factorials.\n",
    "- Start calculating the factorail from n = 3 to n = 10 by running the loop from 3 to 10.\n",
    "- Appending each factorial to the list of factorials.\n",
    "- Print the final list of factorials of 10 numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5803731c-0525-448a-b861-413d0d1c0408",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 10 Factorial numbers : [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "list39_Fact_list = [1,1,2]\n",
    "\n",
    "for i in range(3,10):\n",
    "    list39_Fact_list.append(i*list39_Fact_list[i-1])\n",
    "\n",
    "print(f\"List of 10 Factorial numbers : {list39_Fact_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c898685-0f94-4288-a176-bb51451b1b72",
   "metadata": {},
   "source": [
    "## 40) Check if two lists have at least one element in common."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "533d83ee-7c25-4299-bd8b-a5db4e0b89d4",
   "metadata": {},
   "source": [
    "## Ans 40)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two lists.\n",
    "- Use the set's intersection property/function to find the common elements in both the list.\n",
    "- If the there is no common element in both the list, set function returns empty set of length of 0.\n",
    "- If the length of set is zero that means there is no common element in both the list.\n",
    "- Else there is/are common element/s in both the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "040515ac-1b96-4f83-9c2c-0317155ba124",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lists=>\n",
      "List 1 : [1, 2, 3]\n",
      "List 2 : [4, 5, 6]\n",
      "There is no common element in two given lists\n"
     ]
    }
   ],
   "source": [
    "list40_1 = [1,2,3]\n",
    "list40_2 = [4,5,6]\n",
    "\n",
    "print(f\"Given lists=>\\nList 1 : {list40_1}\\nList 2 : {list40_2}\")\n",
    "if len(set(list40_1).intersection(set(list40_2))) != 0:\n",
    "    print(\"There is/are common element/s in two given lists\")\n",
    "else:\n",
    "    print(\"There is no common element in two given lists\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec78841-84e0-444b-b466-f62ff35cd99a",
   "metadata": {},
   "source": [
    "## 41) Remove all elements from a list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68078db-d143-4ff2-9d8b-55fc5ec1aba9",
   "metadata": {},
   "source": [
    "## Ans 41)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of elements\n",
    "- Use clear() function to remove all element from the list.\n",
    "- print list after removing all element form it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "d0fe9ee7-fc45-4b01-9504-df7b5fa450c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5, 6, 7, 8, 9] \n",
      "List after removing all elemnts : [] \n"
     ]
    }
   ],
   "source": [
    "# create/take a list of elements\n",
    "list41 = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "print(f\"Given list : {list41} \")\n",
    "# Use clear() function to remove all element of the list.\n",
    "list41.clear()\n",
    "\n",
    "# print list after removing all element form it\n",
    "print(f\"List after removing all elemnts : {list41} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d37095d-572d-42b4-b9b2-8076730f41f3",
   "metadata": {},
   "source": [
    "## 42) Replace negative numbers in a list with 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bba6850-62f4-4ea7-8ac5-f943be96e893",
   "metadata": {},
   "source": [
    "## Ans 42)\n",
    "\n",
    "- Create a list of negative and positive elements.\n",
    "- Traverse through the list.\n",
    "- Check whether a number/element is negative(if num < 0) replace it with 0 else don't.\n",
    "- Print the updated list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "25862fb0-1546-4966-bc5a-247df5433d50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, -2, -2, -10, 7, 8, -11]\n",
      "List after replacin negative numbers with zero : [1, 0, 0, 0, 7, 8, 0] \n"
     ]
    }
   ],
   "source": [
    "# Create a list of negative and positive elements.\n",
    "list42 = [1,-2,3-5,-10,7,8,-11]\n",
    "\n",
    "print(f\"Given list is : {list42}\")\n",
    "# Traverse through the list.\n",
    "# Check whether a number/element is negative(if num < 0) replace it with 0 else don't.\n",
    "for i in range(len(list42)):\n",
    "    if list42[i] < 0:\n",
    "        list42[i] = 0\n",
    "        \n",
    "# Print the updated list.\n",
    "print(f\"List after replacin negative numbers with zero : {list42} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98efb4d7-329b-46a5-98a8-f6e1a5a96583",
   "metadata": {},
   "source": [
    "## 43) Convert a string into a list of words."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9934d2bb-0e39-4aa7-8d25-3dded05bf988",
   "metadata": {},
   "source": [
    "## Ans 43)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a string of words.\n",
    "- Using split function, convert each word of string into list and store it in a variable, as we know that string is an immutable data type.\n",
    "- print the final list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "8c304600-578f-4fa9-aafd-bb98cb34e4cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : My name is Noorain Raza\n",
      "List of words : ['My', 'name', 'is', 'Noorain', 'Raza'] \n"
     ]
    }
   ],
   "source": [
    "# Take the string.\n",
    "list43 = \"My name is Noorain Raza\"\n",
    "\n",
    "print(f\"Given string : {list43}\")\n",
    "# Use string's list() function to convert a string to a list of characters.\n",
    "list43_list = list43.split()\n",
    "\n",
    "# Print the list of chacters.\n",
    "print(f\"List of words : {list43_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8548ec39-d48c-4787-be0c-1a53b3d2c1e8",
   "metadata": {},
   "source": [
    "## 44) Convert a list of words into a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf3fb847-588a-4681-888f-72eec30b8a80",
   "metadata": {},
   "source": [
    "## Ans 44)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of words.\n",
    "- Using join function convert list of words/string into string.\n",
    "- Joing function takes iterables with iterators as string.\n",
    "- print the converted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "4183c026-4900-4597-ac54-7b1a9b89adf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of word : ['My', 'name', 'is', 'Noorain', 'Raza'] \n",
      "Converted String  is : My name is Noorain Raza\n"
     ]
    }
   ],
   "source": [
    "# Create a list of words.\n",
    "# Using join function convert list of words/string into string.\n",
    "# Joing function takes iterables with iterators as string.\n",
    "list44 = ['My','name','is','Noorain','Raza']\n",
    "\n",
    "# print the converted string.\n",
    "print(f\"Given list of word : {list44} \\nConverted String  is : {' '.join(list44)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e732e24-30b4-4788-8d7a-60bfe358a2dd",
   "metadata": {},
   "source": [
    "## 45) Create a list of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f89642aa-79ec-48a2-a5b1-5b1c481985b4",
   "metadata": {},
   "source": [
    "## Ans 45)\n",
    "\n",
    "#### Steps:\n",
    "- Take a value of n from user.\n",
    "- Create an empty list to store power of 2s.\n",
    "- Run the loop n times to calculate the n power of 2 and append each value to empty list.\n",
    "- Print the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "4bbaa1fe-4c1b-4993-af45-91d561e54454",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the value of n :  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of powers of 2 : [1, 2, 4, 8]\n"
     ]
    }
   ],
   "source": [
    "# Take a value of n from user\n",
    "n = int(input(\"Enter the value of n : \"))\n",
    "\n",
    "# Create an empty list to store power of 2s.\n",
    "list_power2 = []\n",
    "\n",
    "# run the loop n times to calculate the n power of 2 and append each value to empty list.\n",
    "for i in range(n):\n",
    "    list_power2.append(2**i)\n",
    "\n",
    "# print the list\n",
    "print(f\"List of powers of 2 : {list_power2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92d9ef8c-41ee-44d3-af35-8d6bf7104488",
   "metadata": {},
   "source": [
    "## 46) Find the longest string in a list of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfa41208-1e5c-484e-818a-3065cf2fdd71",
   "metadata": {},
   "source": [
    "## Ans 46)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of words/strings.\n",
    "- Initialse a max_len variable by 0 and max_len_word by empty string.\n",
    "- Traverse through the list of words/string.\n",
    "- Update max_len and max_len_word, if current length of word is greater than previous word.\n",
    "- Print the longest string/word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "ccd6df65-f460-4260-be44-c33a2f5a3c76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of strings is : ['You', 'are', 'very', 'beautifull', 'guy'] \n",
      "Longest string in given list of strings is : beautifull \n"
     ]
    }
   ],
   "source": [
    "# create a list of strings\n",
    "list46 = ['You','are','very','beautifull','guy']\n",
    "\n",
    "max_len = 0\n",
    "max_len_word = ''\n",
    "for word in list46:\n",
    "    if len(word) > max_len:\n",
    "        max_len = len(word)\n",
    "        max_len_word = word\n",
    "\n",
    "\n",
    "print(f\"Given list of strings is : {list46} \\nLongest string in given list of strings is : {max_len_word} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a44bb7-9d15-4ce7-b925-5a9d8b101ab7",
   "metadata": {},
   "source": [
    "## 47) Find the shortest string in a list of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "087eca73-3b4c-44b9-9598-4c44066bd128",
   "metadata": {},
   "source": [
    "## Ans 47)\n",
    "\n",
    "#### Steps:\n",
    "- Create a list of words/strings.\n",
    "- Initialse a min_len variable by very high value and min_len_word by empty string.\n",
    "- Traverse through the list of words/string.\n",
    "- Update min_len and min_len_word, if current length of word is less than previous word.\n",
    "- Print the shortest string/word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "bcef5c4a-149b-49b7-9033-3f57da1742a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of strings is : ['You', 'are', 'very', 'beautifull', 'guy'] \n",
      "Longest string in given list of strings is : You \n"
     ]
    }
   ],
   "source": [
    "# create a list of strings\n",
    "list47 = ['You','are','very','beautifull','guy']\n",
    "\n",
    "min_len = 99999\n",
    "min_len_word = ''\n",
    "for word in list47:\n",
    "    if len(word) < min_len :\n",
    "        min_len = len(word)\n",
    "        min_len_word = word\n",
    "\n",
    "\n",
    "print(f\"Given list of strings is : {list47} \\nLongest string in given list of strings is : {min_len_word} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43220410-763f-4864-9b77-de6c8d331045",
   "metadata": {},
   "source": [
    "## 48) Create a list of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b03bd5a2-3121-4478-aa56-624367cb8660",
   "metadata": {},
   "source": [
    "## Ans 48)\n",
    "\n",
    "1) Triangular series : 1,3,6,10,15,21,....\n",
    "2) Formula : Tn = n(n+1)/2\n",
    "\n",
    "#### Steps:\n",
    "- Take value of n from the user.\n",
    "- Generate n triangular numbers list by using formula.\n",
    "- Append each triangular number to empty list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "d94b33dc-dc3d-4cd9-9df4-100b5b1342c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n :  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Triangular list of 6 numbers : [1, 3, 6, 10, 15, 21] \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter value of n : \"))\n",
    "\n",
    "triangular_list = []\n",
    "for i in range(1,n+1):\n",
    "    Ti = int(i*(i+1)/2)\n",
    "    triangular_list.append(Ti)\n",
    "    \n",
    "print(f\"Triangular list of {n} numbers : {triangular_list} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "246d12e7-5f41-4e3a-acc6-311858dff4dc",
   "metadata": {},
   "source": [
    "## 49) Check if a list contains another list as a subsequence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04af0b0-f339-4eba-9f1c-a7a4ef1720a1",
   "metadata": {},
   "source": [
    "## Ans 49)\n",
    "\n",
    "#### Steps:\n",
    "- Create/Take two lists.\n",
    "- 1) Main list : In which subsequence to be search.\n",
    "- 2) Subsequence list : list to be seach in main list.\n",
    "- First of all search the 1st element of subsequence into main list, If 1st element exists in main list then only we will check other elements otherwise return/print main list does not contain another list as a subsequence.\n",
    "- If 1st element present in main list then find the index at which position the element is.\n",
    "- Once index is found we can slice the main from that index till  till length of subsequence.\n",
    "- If sliced list and another list are equal that means main list contains another list as a subsequence else main list does not contain another list as a subsequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5c093a5b-88b0-48c3-9d03-165b9d4a7545",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5]\n",
      "Another list : [2, 3] \n",
      "List contains another list as a subsequence.\n"
     ]
    }
   ],
   "source": [
    "list49_1= [1,2,3,4,5]\n",
    "list49_2 = [2,3]\n",
    "\n",
    "def subsequence(list49,search_sequence):\n",
    "    for ele in search_sequence:\n",
    "        if ele not in list49:\n",
    "            return print(f\"List doesn't contain another list as a subsequence.\")\n",
    "        else:\n",
    "            for idx, element in enumerate(list49):\n",
    "                if element == search_sequence[0]:\n",
    "                    if list49[idx:idx+len(search_sequence)] == search_sequence[0:len(search_sequence)]:\n",
    "                        return print(f\"List contains another list as a subsequence.\")\n",
    "                    else:\n",
    "                        return print(f\"List doesn't contain another list as a subsequence.\")\n",
    "\n",
    "                    \n",
    "print(f\"Given list : {list49_1}\\nAnother list : {list49_2} \")                    \n",
    "subsequence(list49_1, list49_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc59fa5-f6f9-4d14-a1bd-5dc470c07f06",
   "metadata": {},
   "source": [
    "## 50)  Swap two elements in a list by their indices."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc2e8daf-858f-453f-8d04-51b74cd8f32c",
   "metadata": {},
   "source": [
    "## Ans 50)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list of elements.\n",
    "- Swap the first and last element by their indices using comma operator.\n",
    "- Print list after swaping the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "ab3186b1-fa35-4931-9b2a-36db7dbc6984",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4]\n",
      "List after swaping 1st and last element : [4, 2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "list50 = [1,2,3,4]\n",
    "\n",
    "print(f\"Given list : {list50}\")\n",
    "\n",
    "# swap the first and last elements by their indices using comma operator\n",
    "list50[0],list50[-1] = list50[-1],list50[0]\n",
    "\n",
    "print(f\"List after swaping 1st and last element : {list50}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edfd8a29-9370-4eea-ae96-27f28704d93a",
   "metadata": {},
   "source": [
    "# TOPIC: Tuple Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19290e89-9508-4c00-a801-0ca7f2e138d6",
   "metadata": {},
   "source": [
    "## 1)  Create a tuple with integers from 1 to 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ca97460-892b-4844-8e8d-a84c7146b3d9",
   "metadata": {},
   "source": [
    "## Ans 1)\n",
    "\n",
    "#### Steps :\n",
    "- A tuple can be created by entering values inside a pair of parentheses i.e (val1,val2...) and store it in a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dd03935a-18f8-4d29-b565-a5af3aed94ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with integers from 1 to 5 is : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# enter the values from 1 to 5 inside a pair of parenthese and store it in a variable.\n",
    "t1 = (1,2,3,4,5)\n",
    "\n",
    "print(f\"Tuple with integers from 1 to 5 is : {t1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cfe6971-a7f0-4304-b7f0-2eab9b90a728",
   "metadata": {},
   "source": [
    "## 2) Access the third element of a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60d9ea3a-50fd-43f5-b590-b9f4a08cf8a9",
   "metadata": {},
   "source": [
    "## Ans 2)\n",
    "\n",
    "#### Steps :\n",
    "- A tuple stores values from 0th index, so to access the 3rd element should at index 2.\n",
    "- Create a tuple and store it in a variable\n",
    "- Print/access the 3rd element by using index value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1f6cf283-90e5-4626-ade0-e7cd3aa6f1e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Third element of given tuple ('my', 'name', 'is', 'noorain') is : is\n"
     ]
    }
   ],
   "source": [
    "# create a tuple and store it in a variable\n",
    "t2 = ('my','name','is','noorain')\n",
    "\n",
    "# print/access the 3rd element by using index value.\n",
    "print(f\"Third element of given tuple {t2} is : {t2[2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c930789a-d8f3-40f5-92af-60b151416b24",
   "metadata": {},
   "source": [
    "## 3) Find the length of a tuple without using the `len()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118c9710-61b3-4af6-9d7e-e85e1c2c7498",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Ans 3)\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- Initialise a counter to store the length of tuple.\n",
    "- Traverse through each element of tuple by using loop and increase the counter value by 1 in each iteration.\n",
    "- In this way we can find the length of a tuple without using the in built len() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d4669306-2926-4f83-80a3-a93a8d315a83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given Tuple is : (1, 2, 3, 4, 5, 6, 7)\n",
      "The length of given tuple is : 7 \n"
     ]
    }
   ],
   "source": [
    "# Create a tuple and store it in a variable\n",
    "t3 = (1,2,3,4,5,6,7)\n",
    "\n",
    "# Initialise a counter to store the length of tuple.\n",
    "counter = 0\n",
    "\n",
    "# Traverse through each element of tuple by using loop and increase the counter value by 1 in each iteration.\n",
    "for i in t3:\n",
    "    counter += 1\n",
    "    \n",
    "# print the length of tuple i.e counter's value\n",
    "print(f\"Given Tuple is : {t3}\\nThe length of given tuple is : {counter} \")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb8c47ff-4e16-41d3-89ea-76ae50a0644b",
   "metadata": {},
   "source": [
    "## 4) Count the occurrences of an element in a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d285f4dc-3f77-42d8-8603-46c06eacff21",
   "metadata": {},
   "source": [
    "## Ans 4)\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- Take an element form the user to count its occurrences in tuple.\n",
    "- By using count() function count the occurrences of given element by passing that element to the count function.\n",
    "- Print the occurrences of the element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "15fd9b3a-38ed-427c-85f3-c0ca75bae066",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 3, 4, 2, 2, 1, 1, 4, 4, 5)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an element to find its occurrences in tuple :  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The occurences of given element 2 in tuple : 3 \n"
     ]
    }
   ],
   "source": [
    "# Create a tuple and store it in a variable\n",
    "t4 = (1,2,3,4,2,2,1,1,4,4,5)\n",
    "\n",
    "print(f\"Given tuple is : {t4}\")\n",
    "\n",
    "# Take an element form the user to count its occurrences in tuple.\n",
    "ele = int(input(\"Enter an element to find its occurrences in tuple : \"))\n",
    "\n",
    "# By using count() function count the occurrences  of given element by passing that element to the count function.\n",
    "# Print the occurrences of the element\n",
    "print(f\"The occurences of given element {ele} in tuple : {t4.count(ele)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2ef8acf-f594-42a4-a133-f3fda36a87fc",
   "metadata": {},
   "source": [
    "## 5) Find the index of the first occurrence of an element in a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a48e400e-5a82-4d3a-bfae-6d53b19770a4",
   "metadata": {},
   "source": [
    "## Ans 5)\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- Take an element form the user to find the index of its first occurrence in tuple.\n",
    "- By using index() function find the occurrences of given element by passing that element to the index function.\n",
    "- Note: index() function returns the index of 1st occurence of given element if present in tuple/list else through error.\n",
    "- Print the index of the element of its first occurrence in tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a13c1d7c-77ad-46cb-847b-bdbbd8694add",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 3, 4, 2, 2, 1, 1, 4, 4, 5)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an element to find its occurrences in tuple :  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The occurences of given element 1 in tuple : 0 \n"
     ]
    }
   ],
   "source": [
    "# Create a tuple and store it in a variable\n",
    "t5 = (1, 2, 3, 4, 2, 2, 1, 1, 4, 4, 5)\n",
    "\n",
    "print(f\"Given tuple is : {t5}\")\n",
    "# Take an element form the user to find the index of its first occurrence in tuple.\n",
    "ele = int(input(\"Enter an element to find its occurrences in tuple : \"))\n",
    "\n",
    "# By using find() function find the occurrences of given element by passing that element to the find function.\n",
    "# Print the index of the element of its first occurrence in tuple.\n",
    "print(f\"The occurences of given element {ele} in tuple : {t5.index(ele)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a31102ed-3d14-4036-8f89-e665f0bba15c",
   "metadata": {},
   "source": [
    "## 6) Check if an element exists in a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a883e526-0c30-45a7-990e-667fce99a1ec",
   "metadata": {},
   "source": [
    "## Ans 6)\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- Take an element form the user to check whether it is present in tuple or not?.\n",
    "- By using 'in' operator, we can search an element exists in a tuple or not.\n",
    "- If element exists, display element exists in a tuple esle element doesn't exist in tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1cd15d80-6be2-4e5f-8bc2-c450c218dfba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : ('noorain', 'imran', 'sudhanshu', 'krish')\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an element/name to check whether it exists in tuple or not :  imran\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wooho !! , Element imran exists in tuple.\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple of string and store it in a variable\n",
    "t6 = ('noorain','imran','sudhanshu','krish')\n",
    "\n",
    "print(f\"Given tuple is : {t6}\")\n",
    "# Take an element form the user to check whether it is present in tuple or not?.\n",
    "name = input(\"Enter an element/name to check whether it exists in tuple or not : \")\n",
    "\n",
    "# By using 'in' operator, we can search an element exists in a tuple or not.\n",
    "# If element exists, display element exists in a tuple esle element doesn't exist in tuple.\n",
    "if name in t6:\n",
    "    print(f\"wooho !! , Element {name} exists in tuple.\")\n",
    "else:\n",
    "    print(f\"Element {name} doesn't exist in tuple.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d74d29ac-ae07-47dd-886c-400e0a7db02f",
   "metadata": {},
   "source": [
    "## 7) Convert a tuple to a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37967ad5-93cc-48fa-b81b-9d0ad95c7705",
   "metadata": {},
   "source": [
    "## Ans 7)\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- By using list() function type caste given tuple into list.\n",
    "- Print the converted list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a80bce62-d1a9-460d-9e28-60462da966f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 3, 4, 5)\n",
      "Converted list is : [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple and store it in a variable\n",
    "t7 = (1,2,3,4,5)\n",
    "\n",
    "print(f\"Given tuple is : {t7}\")\n",
    "# By using list() function type caste given tuple into list.\n",
    "t7 = list(t7)\n",
    "\n",
    "# Print the converted list.\n",
    "print(f\"Converted list is : {t7}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "153d15eb-d2c4-4186-a8de-f86988a822b1",
   "metadata": {},
   "source": [
    "## 8) Convert a list to a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "452f41d6-d0f6-4f88-ad29-e5c93b2a7bf0",
   "metadata": {},
   "source": [
    "## Ans 8)\n",
    "\n",
    "#### Steps :\n",
    "- Create a list and store it in a variable\n",
    "- By using tuple() function type caste given list into tuple.\n",
    "- Print the converted tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "04c3c2bf-3797-4a1b-bff4-b0aa83d7a0dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list is : [1, 2, 3, 4, 5], its type is : <class 'list'>\n",
      "Converted tuple is : (1, 2, 3, 4, 5), its type is : <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Create a list and store it in a variable\n",
    "l8 = [1,2,3,4,5]\n",
    "\n",
    "print(f\"Given list is : {l8}, its type is : {type(l8)}\")\n",
    "# By using tuple() function type caste given list into tuple.\n",
    "l8 = tuple(l8)\n",
    "\n",
    "# Print the converted tuple.\n",
    "print(f\"Converted tuple is : {l8}, its type is : {type(l8)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfe412e-1cf7-49d5-9494-626108b7965d",
   "metadata": {},
   "source": [
    "## 9)  Unpack the elements of a tuple into variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8498fbd5-38bf-4a15-9ccf-42378acb74d4",
   "metadata": {},
   "source": [
    "## Ans 9)\n",
    "\n",
    "1) Before unpacking the elements of a tuple lets understand what is packing and unpacking of a tuple.\n",
    "2) Packing of a tuple : When we assign values to a tuple (in pair of parentheses) or when we create a tuple then it is called \"Packing of a tuple\"\n",
    "3) Unpacking of a tuple : When we retrieve the values of a tuple and store each value in a variable then it is called \"Unpacking of a tuple\"\n",
    "4) Task : store/assign each value of given tuple in a variable.\n",
    "5) NOTE: Number of varaibles should be same as the number of element in tuple.\n",
    "\n",
    "#### Steps :\n",
    "- Create a tuple and store it in a variable\n",
    "- Assign each value of tuple to varaibles. How?\n",
    "- - Use an assignmnet operator '=', on LHS of this operator write the varaible names and tuple should be on RHS. \n",
    "- Print each variable values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "139ddfef-43c6-476a-8efd-db78f445d34a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given Packed tuple is : (10, 20, 30, 40)\n",
      "Elements of tuple after unpacking it : \n",
      "var1 = 10,var2 = 20,var3 = 30,var4 = 40\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple and store it in a variable\n",
    "t9 = (10,20,30,40)\n",
    "\n",
    "print(f\"Given Packed tuple is : {t9}\")\n",
    "# Assign each value of tuple to varaibles. How?\n",
    "# Use an assignmnet operator '=', on LHS of this operator write the varaible names and tuple should be on RHS. \n",
    "var1,var2,var3,var4 = t9\n",
    "\n",
    "# Print each variable values.\n",
    "print(f\"Elements of tuple after unpacking it : \\nvar1 = {var1},var2 = {var2},var3 = {var3},var4 = {var4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f23d94a1-bcf0-4d7b-9911-205847c4d494",
   "metadata": {},
   "source": [
    "## 10) Create a tuple of even numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "471b1f65-a438-4745-b695-d8a6adbe62b8",
   "metadata": {},
   "source": [
    "## Ans 10)\n",
    "\n",
    "1) Even numbers are those numbers which are divisible by two.\n",
    "\n",
    "#### Steps :\n",
    "- Create an empty list to store even numbers.\n",
    "- Run a loop in range of 1 to 11.\n",
    "- Check a number is even or not. \n",
    "- If a number is even, append it into empty list else don't\n",
    "- Convert list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3bfd2425-9d4d-4785-8a14-1f2e72f34ebd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of even numbers from 1 to 10 : (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "# Create an empty list to store even numbers.\n",
    "lis10 = []\n",
    "\n",
    "# Run a loop in range of 1 to 11.\n",
    "# Check a number is even or not. \n",
    "# If a number is even, append it into our list else don't\n",
    "for num in range(1,11):\n",
    "    if num%2 == 0:\n",
    "        lis10.append(num)\n",
    "\n",
    "# Convert list into tuple and print it.\n",
    "lis10 = tuple(lis10)\n",
    "print(f\"Tuple of even numbers from 1 to 10 : {lis10}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "732263dd-617f-4605-af46-c1c621caf7b7",
   "metadata": {},
   "source": [
    "## 11) Create a tuple of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58057619-ba75-43de-bba0-ca31c40c5d1c",
   "metadata": {},
   "source": [
    "## Ans 11)\n",
    "\n",
    "1) Odd numbers are those numbers which are not divisible by two.\n",
    "\n",
    "#### Steps :\n",
    "- Create an empty list to store odd numbers.\n",
    "- Run a loop in range of 1 to 11.\n",
    "- Check a number is odd or not. \n",
    "- If a number is odd, append it into empty list else don't\n",
    "- Convert list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "790b5975-13e7-4bd9-b0f8-97ccda8db5bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of odd numbers from 1 to 10 : (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "# Create an empty list to store odd numbers.\n",
    "lis11 = []\n",
    "\n",
    "# Run a loop in range of 1 to 11.\n",
    "# Check a number is odd or not. \n",
    "# If a number is odd, append it into our list else don't\n",
    "for num in range(1,11):\n",
    "    if num%2 != 0:\n",
    "        lis11.append(num)\n",
    "\n",
    "# Convert list into tuple and print it.\n",
    "lis11 = tuple(lis11)\n",
    "print(f\"Tuple of odd numbers from 1 to 10 : {lis11}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8def215-ad05-4252-ace5-34b8ca77e079",
   "metadata": {},
   "source": [
    "## 12) Concatenate two tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "170a1315-d275-487f-96f0-d0fe4a4dbfab",
   "metadata": {},
   "source": [
    "## Ans 12)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take two tuples.\n",
    "- Using plus operator '+' concatenate both the tuples.\n",
    "- Print the concatenated tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7db5a812-d9b1-4871-a92e-daa1507c52ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuples are :\n",
      "Tuple 1 : (1, 2, 3, 4)\n",
      "Tuple 2 : (5, 6, 7)\n",
      "Concatenated tuple is : (1, 2, 3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "# Create/take two tuples.\n",
    "t12_1 = (1,2,3,4)\n",
    "t12_2 = (5,6,7)\n",
    "\n",
    "print(f\"Given tuples are :\\nTuple 1 : {t12_1}\\nTuple 2 : {t12_2}\")\n",
    "\n",
    "# Using plus operator '+' concatenate both the tuples.\n",
    "# Print the concatenated tuple.\n",
    "print(f\"Concatenated tuple is : {t12_1 + t12_2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34908fe1-d873-4e75-b0b6-9622235563a4",
   "metadata": {},
   "source": [
    "## 13) Repeat a tuple three times."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64e26570-5023-40b2-93ac-eb6f7dad7f23",
   "metadata": {},
   "source": [
    "## Ans 13)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a tuple.\n",
    "- Mupltiply tuple by 3 using operator '*'\n",
    "- Print the repeated tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "49314ae6-c19c-4c63-b253-4f219532fa13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 3)\n",
      "Repeated tuple 3 times : (1, 2, 3, 1, 2, 3, 1, 2, 3) \n"
     ]
    }
   ],
   "source": [
    "# Create/take a tuple.\n",
    "t13 = (1,2,3)\n",
    "\n",
    "print(f\"Given tuple is : {t13}\")\n",
    "# Mupltiply tuple by 3 using operator '*'\n",
    "# Print the repeated tuple.\n",
    "print(f\"Repeated tuple 3 times : {t13*3} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31f5a3aa-fcc0-47fa-a437-658c94cfe145",
   "metadata": {},
   "source": [
    "## 14) Check if a tuple is empty."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69223b16-e1a7-4f7b-8779-ac6a06b5f678",
   "metadata": {},
   "source": [
    "## Ans 14)\n",
    "\n",
    "1) empty tuple : A tuple is called empty if its length is zero. That means there is no element inside it.\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a tuple.\n",
    "- Using len() function find the length of tuple.\n",
    "- If length of a tuple is zero that means tuple is empty else tuple is not empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "28610cd9-1ce1-4b35-a914-aa717b83b6ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : () is empty.\n"
     ]
    }
   ],
   "source": [
    "# Create/take a tuple.\n",
    "t14 = ()\n",
    "\n",
    "# Using len() function find the length of tuple.\n",
    "# If length of a tuple is zero that means tuple is empty else tuple is not empty.\n",
    "if len(t14) > 0:\n",
    "    print(f\"Given tuple : {t14} is not empty.\")\n",
    "else:\n",
    "    print(f\"Given tuple : {t14} is empty.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06231cd-5e5c-4535-bbef-3ec58861a7d8",
   "metadata": {},
   "source": [
    "## 15) Create a nested tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9501e554-7e3c-43c7-835f-3167a991ca57",
   "metadata": {},
   "source": [
    "## Ans 15)\n",
    "\n",
    "1) Nested tuple : When there is/are tuple(s) inside a main tuple then main tuple is called as 'Nested tuple'.\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a tuple and assign some values.\n",
    "- While assigning value to tuple , In place of a value assign a tuple.\n",
    "- Print nested tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a27c681b-2820-4d53-92d0-7d45acca1493",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested tuple is : (1, 2, 3, 4, (8, 1, 2), 10) , <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t15 = (1,2,3,4,(8,1,2),10)\n",
    "\n",
    "print(f\"Nested tuple is : {t15} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937b628c-9a90-4d8e-8472-cfa90d79c812",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 16) Access the first element of a nested tuple.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c901b424-2ebd-48db-9ea7-f087e8f34877",
   "metadata": {},
   "source": [
    "## Ans 16)\n",
    "\n",
    "1) Note : To access the first element of a nested tuple. First question should come in mind is : how system/python can know where is a tuple inside the main tuple ?\n",
    "2) To know this, we can check the data type of each element of a tuple by traversing through it.\n",
    "3) If type of any element is tuple then we can access its first element by indexing.\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a nested tuple.\n",
    "- Traverse through tuple and check it's data type.\n",
    "- If data type is tuple of any element then using indexing access first element.\n",
    "- Print the first element of a nested tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "adb9c3d9-ffea-475c-a474-b53b4755c6c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (12, 23, 50, (10, 2, 8), 1)\n",
      "First element of a nested tuple is : 10\n"
     ]
    }
   ],
   "source": [
    "# Create/take a nested tuple.\n",
    "t16 = (12,23,50,(10,2,8),1)\n",
    "\n",
    "print(f\"Given tuple is : {t16}\")\n",
    "# Traverse through tuple and check it's data type.\n",
    "# If data type is tuple of any element then using indexing access first element.\n",
    "# Print the first element of a nested tuple.\n",
    "for ele in t16:\n",
    "    if type(ele) == tuple:\n",
    "        print(f\"First element of a nested tuple is : {ele[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "655eb8f5-0e1f-4573-b206-ccff0bfbdb69",
   "metadata": {},
   "source": [
    "## 17) Create a tuple with a single element."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20e3b9af-5a8b-4562-84ef-f72570e497c2",
   "metadata": {},
   "source": [
    "## Ans 17)\n",
    "\n",
    "1) Note : A tuple with a single element is created by enterting a value then a comma.\n",
    "2) For ex- if we create a tuple like this  : t = (1) <-- X (wrong way), it is an integer not a tuple.\n",
    "3) if we create like this : t = (1,) , right way\n",
    "\n",
    "#### Steps :\n",
    "- Enter a value in pair of parentheses and enter a comma (,).\n",
    "- In this way we can create a tuple with a single element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "69f91c0d-7e12-40f6-9b19-fd1cd8a56e16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with a single element : (1,) and its data type is : <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Enter a value in pair of parentheses and enter a comma (,).\n",
    "t17 = (1,)\n",
    "\n",
    "# print it and its type\n",
    "print(f\"Tuple with a single element : {t17} and its data type is : {type(t17)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0527e2-efb0-424b-9864-b56799dd410f",
   "metadata": {},
   "source": [
    "## 18) Compare two tuples.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13e7e550-fdd6-4f4f-bc9d-77fc900d2669",
   "metadata": {},
   "source": [
    "## Ans 18)\n",
    "\n",
    "1) We can perform different comparison task on tuples.\n",
    "2) For ex- Check whether two tuples are equal to each other or not ?\n",
    "3) For ex- Check whether a tuple is greater/lesser than to other tuple ? \n",
    "\n",
    "#### Steps :\n",
    "- Lets Check whether two tuples are equal to each other or not?\n",
    "- create/Take two tuples.\n",
    "- Using equal operator '==' compare both tuples.\n",
    "- Print Both are equal if condition is true else both are not equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "97eb4e5e-f1b5-4f72-be3a-054ec9341cfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuples:\n",
      "Tuple 1 : (1, 2, 3)\n",
      "Tuple 2 : (1, 2, 3)\n",
      "Given tuples are equal.\n"
     ]
    }
   ],
   "source": [
    "# Lets Check whether two tuples are equal to each other or not?\n",
    "# create/Take two tuples.\n",
    "t18_1 = (1,2,3)\n",
    "t18_2 = (1,2,3)\n",
    "\n",
    "print(f\"Given tuples:\\nTuple 1 : {t18_1}\\nTuple 2 : {t18_2}\")\n",
    "# Using equal operator '==' compare both tuples.\n",
    "# Print Both are equal if condition is true else both are not equal.\n",
    "if t18_1 == t18_2 :\n",
    "    print(\"Given tuples are equal.\")\n",
    "else:\n",
    "    print(\"Given tuples are not equal.\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6819ddd9-e15e-4b76-a652-46c8d9535450",
   "metadata": {},
   "source": [
    "## 19) Delete a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6c09c9f-bf54-493f-a0f8-32d22d24597e",
   "metadata": {},
   "source": [
    "## Ans 19)\n",
    "\n",
    "1) Delete a tuple using 'del' keyword. del keyword is used to delete the object in python.\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a tuples.\n",
    "- Using del keyword delete given tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a3120ff9-1beb-4d65-9b0d-4d196d173ecb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 21, 32) \n",
      "Tuple is successfully deleted.\n"
     ]
    }
   ],
   "source": [
    "t19 = (1,21,32)\n",
    "print(f\"Given tuple is : {t19} \")\n",
    "\n",
    "# Delete tuple using del keyword. \n",
    "del t19\n",
    "\n",
    "print(\"Tuple is successfully deleted.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8dd0205-317c-407f-a5a7-05e6b3ab12d2",
   "metadata": {},
   "source": [
    "## 20) Slice a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "032580b9-c1b3-4bfe-beea-89b13525b4bc",
   "metadata": {},
   "source": [
    "## Ans 20)\n",
    "\n",
    "1) As tuple is an ordered collection of data elements.\n",
    "2) we can slice a tuple by using pair of bracket i.e '[]'\n",
    "3) To slice a tuple we have to pass starting, ending and step/jump points inside the pair of bracket.\n",
    "4) Syntax : tuple[start : end : step]\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a tuples.\n",
    "- Lets access only starting 5 values of tuple by passing start to 0, end to 5, left the step to its by default value.\n",
    "- Print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6ac4c895-ad41-4b14-a15e-d2e0518ea96a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
      "Tuple after slicing starting 5 values : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# create/Take a tuples.\n",
    "t20 = (1,2,3,4,5,6,7,8,9,10)\n",
    "\n",
    "print(f\"Given tuple is : {t20}\")\n",
    "\n",
    "# Lets access only starting 5 values of tuple by passing start to 0, end to 5, left the step to its by default value.\n",
    "# Print it\n",
    "print(f\"Tuple after slicing starting 5 values : {t20[0:5]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cda35311-b05f-40ed-ba18-75df05853e05",
   "metadata": {},
   "source": [
    "## 21) Find the maximum value in a tuple.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd5f23b-528c-49c5-8bbb-5282ea98a438",
   "metadata": {},
   "source": [
    "## Ans 21)\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a tuples.\n",
    "- Using max() function find the max value in a tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "6058e8b0-dc32-41c9-9012-d312c9e54c2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (10, 20, 30, 40, 50)\n",
      "Maximum element in tuple is : 50\n"
     ]
    }
   ],
   "source": [
    "# create/Take a tuples.\n",
    "t21 = (10,20,30,40,50)\n",
    "\n",
    "# Using max() function find the max value in a tuple and print it.\n",
    "print(f\"Given tuple : {t21}\\nMaximum element in tuple is : {max(t21)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9dbcb3a-821a-4ea8-980c-d2be6526dc5b",
   "metadata": {},
   "source": [
    "## 22)  Find the minimum value in a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed77d0f1-c9c0-4370-aeee-5cc559387f44",
   "metadata": {},
   "source": [
    "## Ans 22)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take a tuples.\n",
    "- Using min() function find the min value in a tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7cb686ab-892e-49e8-a965-bc136d0f6bf1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (10, 20, 30, 40, 50)\n",
      "Minimum element in tuple is : 10\n"
     ]
    }
   ],
   "source": [
    "# create/Take a tuples.\n",
    "t21 = (10,20,30,40,50)\n",
    "\n",
    "# Using min() function find the min value in a tuple and print it.\n",
    "print(f\"Given tuple : {t21}\\nMinimum element in tuple is : {min(t21)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc6fdee-e5f3-4234-820a-2e515a0e561e",
   "metadata": {},
   "source": [
    "## 23) Convert a string to a tuple of characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dac2a04-d0e3-4c3d-99d9-74062b8574b1",
   "metadata": {},
   "source": [
    "## Ans 23)\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a string.\n",
    "- Using list() function convert string into list of characters.\n",
    "- Convert list into tuple by type casting list into tuple.\n",
    "- Print tuple of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "a8d28c26-328f-4b0b-9413-70e953dfbe68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : data\n",
      "Tuple of characters : ('d', 'a', 't', 'a')\n"
     ]
    }
   ],
   "source": [
    "# create/Take a string.\n",
    "l23_str = 'data'\n",
    "print(f\"Given string is : {l23_str}\")\n",
    "\n",
    "# Using list() function convert string into list of characters.\n",
    "l23_str = list(l23_str)\n",
    "\n",
    "# Convert list into tuple by type casting list into tuple.\n",
    "l23_str = tuple(l23_str)\n",
    "\n",
    "# Print tuple of characters.\n",
    "print(f\"Tuple of characters : {l23_str}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee498da9-3b5b-4e80-bbfe-5e121451cd51",
   "metadata": {},
   "source": [
    "## 24)  Convert a tuple of characters to a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c399f11-0a7e-4c1e-8bfc-c78949984b2d",
   "metadata": {},
   "source": [
    "## Ans 24)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take tuple of characters.\n",
    "- Using join() function, convert a tuple of characters into string.\n",
    "- Print converted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "f38dc864-28e8-4eb1-8cea-15418e114da0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data\n"
     ]
    }
   ],
   "source": [
    "l24 = ('d', 'a', 't', 'a')\n",
    "print(f\"Given tuple of characters : {l24}\")\n",
    "\n",
    "# convert characters of tuple to string using .join() function\n",
    "print(\"Converted string : \",''.join(l24))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea174f68-3f27-4d88-90d4-057e36c95156",
   "metadata": {},
   "source": [
    "## 25)  Create a tuple from multiple data types.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e3184c0-5677-47dd-92ca-39bd5952b1ef",
   "metadata": {},
   "source": [
    "## Ans 25)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take a tuple that contains element of different data types.\n",
    "- Print craeted tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f9c6a432-3240-41b6-aa0a-3fc3603cedcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with elements of differenet data types : (1, 'data', 0.4, None, True, (5+6j))\n"
     ]
    }
   ],
   "source": [
    "# Create/Take a tuple that contains element of different data types.\n",
    "l25 = (1,'data', 0.4, None, True, 5+6j)\n",
    "\n",
    "# Print craeted tuple.\n",
    "print(f\"Tuple with elements of differenet data types : {l25}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72be5ea2-9dc9-413b-82f9-c2c6b6843b38",
   "metadata": {},
   "source": [
    "## 26) Check if two tuples are identical."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddf384b0-0ee8-46d4-acf1-d08192449c9c",
   "metadata": {},
   "source": [
    "## Ans 26)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take two tuples.\n",
    "- Using equal operator '==' compare both tuples.\n",
    "- Print Both tuples are identical if condition is true else both are not identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "c208dd89-2d36-4d4f-947b-f73bc0a02451",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuples:\n",
      "Tuple 1 : (1, 2, 3)\n",
      "Tuple 2 : (1, 2, 6)\n",
      "Given tuples are not identical.\n"
     ]
    }
   ],
   "source": [
    "# create/Take two tuples.\n",
    "t26_1 = (1,2,3)\n",
    "t26_2 = (1,2,6)\n",
    "\n",
    "print(f\"Given tuples:\\nTuple 1 : {t26_1}\\nTuple 2 : {t26_2}\")\n",
    "\n",
    "# Using equal operator '==' compare both tuples.\n",
    "# Print Both tuples are identical if condition is true else both are not identical.\n",
    "if t26_1 == t26_2 :\n",
    "    print(\"Given tuples are identical.\")\n",
    "else:\n",
    "    print(\"Given tuples are not identical.\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3929ec75-9cad-4871-b563-4738f52cc89a",
   "metadata": {},
   "source": [
    "## 27) Sort the elements of a tuple.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10571e01-50ac-454c-9e4b-f7bf13b0a3db",
   "metadata": {},
   "source": [
    "## Ans 27)\n",
    "\n",
    "1) Note: Tuple is an immutable data type. We can't change the position of its element directly.\n",
    "2) Sorting of tuple can be performed using sorted() function. When we pass a tuple to it, internally it converts tuple into list then perform sorting and return the list. So we have to convert back that list into tuple.\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take tuple of elements.\n",
    "- Using sorted() function, sort the elements of a tuple.\n",
    "- Pass a tuple to sorted() function, whatever it returns type caste it into tuple.\n",
    "- Print the sorted tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "05adf377-7730-41ee-9a72-bb4bf9f798d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (4, 10, 8, 1, 7)\n",
      "Sorted tuple : (1, 4, 7, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "# Create/Take tuple of elements.\n",
    "t26 = (4,10,8,1,7)\n",
    "print(f\"Given tuple is : {t26}\")\n",
    "\n",
    "# Using sort() function, sort the elements of a tuple in ascending or descending order.\n",
    "# Print the sorted tuple.\n",
    "print(f\"Sorted tuple : {tuple(sorted(t26))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88a37d0d-3787-4999-b4ec-76abe6474c79",
   "metadata": {},
   "source": [
    "## 28) Convert a tuple of integers to a tuple of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df1dc4c3-7555-496a-b1e5-9a4f56593c10",
   "metadata": {},
   "source": [
    "## Ans 28)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take tuple of intergers.\n",
    "- Convert it into list.\n",
    "- Using map function convert each interger into string.\n",
    "- Convert the list return from map function into tuple\n",
    "- Print tuple of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "8af8b7a3-03de-4d3d-b13a-d25fafd3b052",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple of integers : (1, 2, 3, 4, 5)\n",
      "Tuple of strings :  ('1', '2', '3', '4', '5')\n"
     ]
    }
   ],
   "source": [
    "# Create/Take tuple of intergers.\n",
    "t27 = (1,2,3,4,5)\n",
    "\n",
    "print(f\"Given tuple of integers : {t27}\")\n",
    "# Convert it into list.\n",
    "# Using map function convert each interger into string.\n",
    "# Convert the list return from map function into tuple\n",
    "# Print tuple of strings.\n",
    "print(\"Tuple of strings : \" ,tuple(map(str,list(t27))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afcad0db-ba2a-4bd3-a35f-7c048a094963",
   "metadata": {},
   "source": [
    "## 29) Convert a tuple of strings to a tuple of integers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3e3fb12-6002-429f-a6fb-05c9e3130318",
   "metadata": {},
   "source": [
    "## Ans 29)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take tuple of strings.\n",
    "- Convert tuple into list.\n",
    "- Using map function convert each string into integer.\n",
    "- Convert the list returned from map function into tuple\n",
    "- Print tuple of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "da7f1129-5bd5-4117-ac8f-3f0dad14264b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple of strings : ('1', '2', '3', '4', '5')\n",
      "Tuple of integers :  (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Create/Take tuple of strings.\n",
    "t28 = ('1', '2', '3', '4', '5')\n",
    "print(f\"Given tuple of strings : {t28}\")\n",
    "\n",
    "# Convert tuple into list.\n",
    "# Using map function convert each string into integer.\n",
    "# Convert the list returned from map function into tuple\n",
    "# Print tuple of integers.\n",
    "print(\"Tuple of integers : \" ,tuple(map(int,list(t28))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f5a0988-1d12-4998-a4b4-eb86c20355fb",
   "metadata": {},
   "source": [
    "## 30) Merge two tuples.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4857e9ab-a50d-4ba7-a7c8-a4eb366cb4f4",
   "metadata": {},
   "source": [
    "## Ans 30)\n",
    "\n",
    "#### Steps :\n",
    "- Create two tuples.\n",
    "- Concatenate two tuples using plus operator and store it in another variable.\n",
    "- Print merged tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "17c70c3d-03c2-484d-91c9-c108ee0d53d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuples are:\n",
      "Tuple 1 : (1, 2, 3, 4, 5)\n",
      "Tuple 2 : (6, 7, 8, 9, 10)\n",
      "Merged tuple is : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n"
     ]
    }
   ],
   "source": [
    "# create two tuples\n",
    "t30_1 = (1,2,3,4,5)\n",
    "t30_2 = (6,7,8,9,10)\n",
    "\n",
    "print(f\"Given tuples are:\\nTuple 1 : {t30_1}\\nTuple 2 : {t30_2}\")\n",
    "# concatenate two tuples using plus operator and store it in another variable\n",
    "merged_tuple = t30_1+t30_2\n",
    "\n",
    "# print merged tuple\n",
    "print(f\"Merged tuple is : {merged_tuple}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f64db6d9-b161-499c-876b-5dbe1d469779",
   "metadata": {},
   "source": [
    "## 31) Flatten a nested tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4a6437f-a0c9-4879-bad4-c2efdbc452d2",
   "metadata": {},
   "source": [
    "## Ans 31) \n",
    "\n",
    "1) Nested tuple : tuple(s) inside a main tuple.\n",
    "2) How to identify a tuple is a nested tuple?\n",
    "- - Ans : By using type() function we can identify there is a nested tuple inside the main list or not.\n",
    "3) How to extract the elements of nested tuple to make the main tuple flatten after identifying a nested tuple?\n",
    "- - Ans : First create an empty list and start appending all the elements of the main tuple , when your code identify there is a nested tuple, By using the nested loop traverse through the nested tuple and append each element of nested tuple to the empty list.\n",
    "4) Finally convert empty list into tuple.\n",
    "\n",
    "\n",
    "#### Steps :\n",
    "- Take/create a nested tuple.\n",
    "- Create an empty list to store flatten tuple elements.\n",
    "- Traverse through the nested tuple and check the type of each element of the tuple.\n",
    "- If the type of element is integer/premitive then append that element into empty list.\n",
    "- If the type of any element is tuple, that means there is a nested tuple, now run a nested loop and traverse through each element of that nested tuple and append each element to empty list.\n",
    "- Convert empty list to tuple\n",
    "- Print the flatten tuple.\n",
    "\n",
    "- NOTE: THIS CODE ONLY WORKS FOR SINGLE NESTED tuple, FOR MULTIPLE NESTED TUPLES, WE HAVE TO USE RECURSION FUNCTION."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "43fe21de-e547-4f8e-b9b9-90a24912b5ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given nested tuple : (12, 2, 3, 4, (7, 8, 10), 8)\n",
      "Flatten tuple is : (12, 2, 3, 4, 7, 8, 10, 8)\n"
     ]
    }
   ],
   "source": [
    "# Take/create a nested tuple.\n",
    "t31 = (12,2,3,4,(7,8,10),8)\n",
    "\n",
    "print(f\"Given nested tuple : {t31}\")\n",
    "# Create an empty list to store flatten tuple elements.\n",
    "flatten_list = []\n",
    "\n",
    "# Traverse through the nested tuple and check the type of each element of the tuple.\n",
    "# If the type of element is integer/premitive then append that element into empty list.\n",
    "# If the type of any element is tuple, that means there is a nested tuple, now run a nested loop and traverse through each element of that nested tuple and append each element to empty list.\n",
    "for ele in t31:\n",
    "    if type(ele) == tuple:\n",
    "        for sub_ele in ele:\n",
    "            flatten_list.append(sub_ele)\n",
    "    else:\n",
    "        flatten_list.append(ele)\n",
    "        \n",
    "# Convert empty list to tuple\n",
    "# Print the flatten tuple.\n",
    "print(f\"Flatten tuple is : {tuple(flatten_list)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "075d8900-d233-48d8-9e9d-af54df826481",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given nested tuple : (12, 2, 3, 4, (7, 8, 10), 8, (12, 3, (4, 5)))\n",
      "Flatten tuple is : (12, 2, 3, 4, 7, 8, 10, 8, 12, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "## SAME TASK BY USING RECURSION FUNCTION FOR MUPLTIPLE NESTED TUPLES\n",
    "\n",
    "# Take/create a nested tuple.\n",
    "recursive_tuple = (12,2,3,4,(7,8,10),8,(12,3,(4,5)))\n",
    "\n",
    "print(f\"Given nested tuple : {recursive_tuple}\")\n",
    "# Create an empty list to store flatten tuple elements.\n",
    "rough_flatten_list = []\n",
    "\n",
    "# Create a recursive function that takes a nestes tuple and convert it into flatter tuple.\n",
    "def flatten(tup):\n",
    "    for ele in tup:\n",
    "        if type(ele) == tuple:\n",
    "            flatten(ele)\n",
    "        else:\n",
    "            rough_flatten_list.append(ele)\n",
    "        \n",
    "# Call flatten function and pass nested tuple\n",
    "flatten(recursive_tuple)\n",
    "print(f\"Flatten tuple is : {tuple(rough_flatten_list)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8786065-acca-4c6b-a95b-41f88e8b77e8",
   "metadata": {},
   "source": [
    "## 32)  Create a tuple of the first 5 prime numbers.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b82eeb7-07c5-478b-bcc2-1776b12762ed",
   "metadata": {},
   "source": [
    "## Ans 32)\n",
    "\n",
    "#### Steps:\n",
    "- Initialise a list of prime numbers by 2.\n",
    "- Create a range of numbers from 3 to 12 which can cover starting 5 prim numbers.\n",
    "- For each num divide it by 2 till num-1, to check whether num is prime or not?\n",
    "- If number is divisible by its any previous number then num is not a prime number else it is and append it. \n",
    "- Convert prime number list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "07ecbc8e-9673-4007-a55d-1b82b64cf04b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 5 prime numbers : (2, 3, 5, 7, 11)\n"
     ]
    }
   ],
   "source": [
    "# Lets initialise a list of prime numbers by 2 that is first prime number.\n",
    "prime_num_list = [2]\n",
    "\n",
    "# create a range of numbers from 3 to 12 which can cover starting 5 prim numbers.\n",
    "# for each num divide it by 2 till num-1, to check whether num is prime or not?\n",
    "# if number is divisible by its any previous number then num is not a prime number else it is and append it.\n",
    "for num in range(3,12):\n",
    "    for i in range(2,num):\n",
    "        if num%i == 0:\n",
    "            break\n",
    "    else:\n",
    "        prime_num_list.append(num)\n",
    "\n",
    "# covert list of prime numbers into tuple and print it.\n",
    "print(f\"Tuple of first 5 prime numbers : {tuple(prime_num_list)}\")          "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9ed151b-e2eb-48d1-b019-a325c9d33777",
   "metadata": {},
   "source": [
    "## 33) Check if a tuple is a palindrome."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f067724-64be-4679-b282-2d1ac68cdc13",
   "metadata": {},
   "source": [
    "## Ans 33) \n",
    "\n",
    "1) Palindrome tuple : A tuple is said to be palindrome if first half of the tuple is same as the reversed of second half of the tuple.\n",
    "\n",
    "### Steps:\n",
    "- Create/take a tuple.\n",
    "- First check the length of the tuple.\n",
    "- 1) If the length is odd then tuple is not a palindrome.\n",
    "- 2) If legth is even then executes below steps.\n",
    "- Divide tuple into two parts i.e t33_1 and t33_2\n",
    "- Reverse the second half of the list/tuple i.e t33_2.\n",
    "- Now compare both of the half of tuple.\n",
    "- If both are same,given tuple is palindrome else not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "2231b769-7191-4e13-b496-f9853cedb894",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is : (1, 2, 1, 1, 2, 1)\n",
      "Given tuple is a palindrome\n"
     ]
    }
   ],
   "source": [
    "# create a tuple\n",
    "t33 = (1,2,1,1,2,1)\n",
    "\n",
    "print(f\"Given tuple is : {t33}\")\n",
    "\n",
    "# A tuple can be palindrome if its length is even.\n",
    "if len(t33)%2 == 0:\n",
    "    t33_1 = list(t33[:len(t33)//2])   # slice tuple form start to middle, convert into list and store it\n",
    "    t33_2 = list(t33[len(t33)//2:])   # slice tuple from middle to end, convert into list and store it\n",
    "\n",
    "    t33_2 = t33_2[::-1]               # reverse the second half of the list\n",
    "\n",
    "    if t33_1 == t33_2:                # compare first half list with second half reversed list.\n",
    "        print(\"Given tuple is a palindrome\")\n",
    "    else:\n",
    "        print(\"Given tuple is not a palindrome\")\n",
    "else:\n",
    "    print(\"Given tuple is not a palindrome\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23bfc079-fdc1-4e2e-98b4-341abc77aa17",
   "metadata": {},
   "source": [
    "## 34) Create a tuple of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "817356ad-ae3b-4947-853c-2bdb40be7f99",
   "metadata": {},
   "source": [
    "## Ans 34)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store squares of numbers from 1 to 5.\n",
    "- Create a range of numbers from 1 to 5.\n",
    "- Append square of each number into list.\n",
    "- Convert the list into tuple and print it    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "7020a7e0-fd10-44c2-a7c9-09e65e0c6367",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of sqaures of numbers from 1 to 5 :  (1, 4, 9, 16, 25)\n"
     ]
    }
   ],
   "source": [
    "# create an empty list to store squares of numbers from 1 to 5.\n",
    "t34_list = []\n",
    "\n",
    "# Create a range of numbers from 1 to 5.\n",
    "# Append square of each number into list.\n",
    "for num in range(1,6):\n",
    "    t34_list.append(num*num)\n",
    "    \n",
    "# Convert the list into tuple and print it    \n",
    "print(\"Tuple of sqaures of numbers from 1 to 5 : \", tuple(t34_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "025d7bca-c256-40b9-b066-e2b553f3707e",
   "metadata": {},
   "source": [
    "## 35) Filter out all even numbers from a tuple.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf999c67-661a-4318-a288-4d976ce2a6e0",
   "metadata": {},
   "source": [
    "## Ans 35)\n",
    "\n",
    "#### Steps:\n",
    "- Create a tuple of even and odd numbers.\n",
    "- Create an empty list to store all even numbers.\n",
    "- Traverse through tuple and check element is even or not. \n",
    "- If element/number is even then append it into empty list.\n",
    "- Convert the empty list into tuple and print it    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "eca600f3-1273-459c-b9be-22acfbbfd0b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
      "Tuple of filtered out even numbers : (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple of even and odd numbers.\n",
    "t35 = (1,2,3,4,5,6,7,8,9,10)\n",
    "\n",
    "# Create an empty list to store all even numbers.\n",
    "even_num_list = []\n",
    "\n",
    "# Traverse through tuple and check element is even or not. \n",
    "# If element/number is even then append it into empty list.\n",
    "for num in t35:\n",
    "    if num%2 == 0:\n",
    "        even_num_list.append(num)\n",
    "# Convert the empty list into tuple and print it   \n",
    "print(f\"Given tuple : {t35}\\nTuple of filtered out even numbers : {tuple(even_num_list)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b87c3cb-b678-43f3-8829-0a5104d6d09e",
   "metadata": {},
   "source": [
    "## 36)  Multiply all elements in a tuple by 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939d0e53-3962-4d56-a004-f7ac8f5661ad",
   "metadata": {},
   "source": [
    "## Ans 36)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a tuple of numbers.\n",
    "- Convert tuple into list and pass it to map function, and write a lambda function that multiply each element of list by 2.\n",
    "- Convert back the returned output of map function into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "6fffe534-b304-4935-8eb7-e621ff49077e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
      "Tuple, after multiplying each element by 2 : (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)\n"
     ]
    }
   ],
   "source": [
    "t36 = (1,2,3,4,5,6,7,8,9,10)\n",
    "print(f\"Given tuple : {t36}\")\n",
    "\n",
    "t36 = tuple(map(lambda x: x*2 ,list(t36)))\n",
    "print(f\"Tuple, after multiplying each element by 2 : {t36}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ebe0a2f-73b7-4b4c-ab83-bdeb8ff11454",
   "metadata": {},
   "source": [
    "## 37) Create a tuple of random numbers.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d2a45fb-42c5-4b91-ba8f-b513ed30afa4",
   "metadata": {},
   "source": [
    "## Ans 37)\n",
    "\n",
    "#### Steps:\n",
    "- Import random module.\n",
    "- Create an empty list to store 10 random numbers.\n",
    "- Create a tuple of 10 random numbers in range from 1 to 20 by running the loop 10 times to generate a random number.\n",
    "- Convert list into tuple and print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "1e1e2a0c-722e-43bb-b1f7-2fc96be3bf2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of 10 random numbers is :  (20, 14, 8, 11, 10, 19, 3, 14, 8, 3)\n"
     ]
    }
   ],
   "source": [
    "# import random module\n",
    "import random\n",
    "\n",
    "# create an empty list to store 10 random numbers.\n",
    "rand_num = []\n",
    "\n",
    "# lets create a tuple of 10 random numbers in range from 1 to 20.\n",
    "for i in range(10):\n",
    "    rand_num.append(random.randint(1,20))\n",
    "\n",
    "# convert list into tuple and print it\n",
    "print(\"Tuple of 10 random numbers is : \", tuple(rand_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36f6de3e-398a-4bcb-acd5-deb3618460f6",
   "metadata": {},
   "source": [
    "## 38) Check if a tuple is sorted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83582f8f-0dab-4cc0-b096-25b46bd8122e",
   "metadata": {},
   "source": [
    "## Ans 38) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take a tuple\n",
    "- Run the loop and compare current element with next element.\n",
    "- If current element is less than next element(condition for ascending order). if yes check it continuously till end, else print tuple is not sorted. \n",
    "- Pack these line of code inside a function and call that function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "ebc0273e-32cc-417f-80bd-76f6817d1602",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple is sorted in ascending order.\n"
     ]
    }
   ],
   "source": [
    "# Create/take a tuple\n",
    "t38 = (1,2,3,5)\n",
    "\n",
    "# run the loop and compare current element with next element.\n",
    "# if current element is less than next element(condition for ascending order). if yes check it continuously till end, else print tuple is not sorted. \n",
    "def sort_check(tup) :\n",
    "    for i in range(len(t38)-1):\n",
    "        if t38[i] > t38[i+1]:\n",
    "            return print(\"Given tuple is not sorted in ascending order.\")\n",
    "    else:\n",
    "        return print(\"Given tuple is sorted in ascending order.\")   \n",
    "    \n",
    "sort_check(t38)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dad7f382-943d-4b61-a5e8-e42943d8acf5",
   "metadata": {},
   "source": [
    "## 39) Rotate a tuple to the left by `n` positions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27d002d-af21-46ff-acb4-13ebd2ebcc9c",
   "metadata": {},
   "source": [
    "## Ans 39)\n",
    "\n",
    "#### Steps:\n",
    "- Create a tuple of elements.\n",
    "- Take the value of n from user to shift the elements by n positions.\n",
    "- Convert tuple into list.\n",
    "- Store first element to temp varaible.\n",
    "- Start shifting the value of list from 2nd element till last.\n",
    "- Once shifting is done, assign the temp value to last index.\n",
    "- Repeat the above steps till n times to rotate the elements of list by n position.\n",
    "- Convert list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8f4ed596-e241-491e-b997-63310c56b645",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4, 5)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n to rotate a tuple by n positions:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple after rotating the elements to the left by 2 position : (3, 4, 5, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple of elements.\n",
    "t40 = (1,2,3,4,5)\n",
    "print(f\"Given tuple : {t40}\")\n",
    "\n",
    "# Convert tuple into list.\n",
    "t40 = list(t40)\n",
    "\n",
    "# Take the value of n from user to shift the elements by n positions.\n",
    "n = int(input(\"Enter value of n to rotate a tuple by n positions: \"))\n",
    "\n",
    "# if value n (posdition to rotate the elements) is less than len of tuple then rotate it by n times.\n",
    "# If value of n is greater than len of tuple then take its module division with length of tuple and do the shifting that many number of times.\n",
    "if n < len(t40):\n",
    "    for i in range(n):\n",
    "        temp = t40[0]\n",
    "        for j in range(1,len(t40)):\n",
    "            t40[j-1] = t40[j]\n",
    "            \n",
    "        t40[-1] = temp\n",
    "else:\n",
    "    for i in range(n%len(t40)):\n",
    "        temp = t40[0]\n",
    "        for j in range(1,len(t40)):\n",
    "            t40[j-1] = t40[j]\n",
    "            \n",
    "        t40[-1] = temp\n",
    "        \n",
    "print(f\"Tuple after rotating the elements to the left by {n} position : {tuple(t40)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1fa0a08-2f95-4eca-b180-6bf3fdedf051",
   "metadata": {},
   "source": [
    "## 40) Rotate a tuple to the right by `n` positions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5f55926-d44e-49b5-8c0b-6dfafed8273a",
   "metadata": {},
   "source": [
    "## Ans 40)\n",
    "\n",
    "#### Steps:\n",
    "- Create a tuple of elements.\n",
    "- Take the value of n from user to shift the elements by n positions.\n",
    "- Convert tuple into list.\n",
    "- Store last element to temp varaible.\n",
    "- Start shifting the value of list from 2nd last element till first element in reverse order.\n",
    "- Once shifting is done, assign the temp value to first index.\n",
    "- Repeat the above steps till n times to rotate the elements of list by n position.\n",
    "- Convert list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "794e23a6-3005-40d4-9a72-f78066a87844",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4, 5)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n to rotate a tuple by n positions:  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple after rotating the elements to the right by 1 position : (5, 1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple of elements.\n",
    "t40 = (1,2,3,4,5)\n",
    "print(f\"Given tuple : {t40}\")\n",
    "\n",
    "# Convert tuple into list.\n",
    "t40 = list(t40)\n",
    "\n",
    "# Take the value of n from user to shift the elements by n positions.\n",
    "n = int(input(\"Enter value of n to rotate a tuple by n positions: \"))\n",
    "\n",
    "# if value n (posdition to rotate the elements) is less than len of tuple then rotate it by n times.\n",
    "# If value of n is greater than len of tuple then take its module division with length of tuple and do the shifting that many number of times.\n",
    "if n < len(t40):\n",
    "    for i in range(n):\n",
    "        temp = t40[-1]\n",
    "        for j in reversed(range(len(t40)-1)):\n",
    "            t40[j+1] = t40[j]\n",
    "            \n",
    "        t40[0] = temp\n",
    "else:\n",
    "    for i in range(n%len(t40)):\n",
    "        temp = t40[0]\n",
    "        for j in reversed(range(len(t40)-1)):\n",
    "            t40[j+1] = t40[j]\n",
    "            \n",
    "        t40[0] = temp\n",
    "        \n",
    "print(f\"Tuple after rotating the elements to the right by {n} position : {tuple(t40)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e49f0445-1add-49e5-8d38-7bd0298d0754",
   "metadata": {},
   "source": [
    "## 41) Create a tuple of the first 5 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "276ab48e-fc60-4748-ad7a-ce0b62050476",
   "metadata": {},
   "source": [
    "## Ans 41) \n",
    "\n",
    "1) Fibonacci Number => F(n) = F(n-1) + F(n-2)\n",
    "\n",
    "#### Steps:\n",
    "- Inittialse a fibonacci series with 0 and 1 (base cases).\n",
    "- Run the from 2 to 5 to generate next 3 numbers of fibonacci series.\n",
    "- Use fibonacci number formula and find next number and append it the list\n",
    "- Convert list into tuple and print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dbcbee10-24c0-4e0c-89a3-29c84209a5d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 5 fibonacci number : (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# inittialse a fibonacci series with 0 and 1 (base cases).\n",
    "fibbo_series = [0,1]\n",
    "\n",
    "# Run the from 2 to 5 to generate next 3 numbers of fibonacci series.\n",
    "# Use fibonacci number formula and find next number and append it the list\n",
    "for i in range(2,5):\n",
    "    fibbo_series.append(fibbo_series[i-1] + fibbo_series[i-2])\n",
    "    \n",
    "# convert list into tuple and print it\n",
    "print(f\"Tuple of first 5 fibonacci number : {tuple(fibbo_series)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1416d7-87e4-4b18-93e2-592228db9542",
   "metadata": {},
   "source": [
    "## 42) Create a tuple from user input.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ba06fa-6948-4976-950f-8163464c38b2",
   "metadata": {},
   "source": [
    "## Ans 42) \n",
    "\n",
    "#### Steps:\n",
    "- Take values from users using input function by displaying a message \"Enter the values of tuple separated by space : \" and store it into a varaible.\n",
    "- Using split function, convert strings into list of string.\n",
    "- Using map function convert this list of string into list of integers by passing int function to map() function.\n",
    "- Finally Convert the list of intergers returned from map function into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bce444fe-6862-4291-b304-e562ccd6e941",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the values of tuple separated by space :  10 20 30 40\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created tuple is : (10, 20, 30, 40)\n"
     ]
    }
   ],
   "source": [
    "# take input form user and store it into a variable.\n",
    "input_values = input(\"Enter the values of tuple separated by space : \")\n",
    "\n",
    "# convert input(string) into list of string, then convert list of string into list of integers then convert\n",
    "# list into tuple and print it\n",
    "print(f\"Created tuple is : {tuple(map(int,input_values.split()))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "945a86d8-0640-4668-9e57-2ced707936a8",
   "metadata": {},
   "source": [
    "## 43) Swap two elements in a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2733454c-fb57-4452-a9db-3bdd3a0f7c2b",
   "metadata": {},
   "source": [
    "## Ans 43)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a tuple of elements.\n",
    "- Convert tuple into list.\n",
    "- Lets Swap the first and last element by their indices using comma operator.\n",
    "- Convert back list into tuple and Print the swaped tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1d4889d4-4a4c-4d37-8a0b-d25c132edb4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4)\n",
      "Tuple after swaping 1st and last element : (4, 2, 3, 1)\n"
     ]
    }
   ],
   "source": [
    "# Create/take a tuple of elements.\n",
    "t43 = (1,2,3,4)\n",
    "print(f\"Given tuple : {t43}\")\n",
    "\n",
    "# convert tuple into list.\n",
    "t43 = list(t43)\n",
    "\n",
    "# swap the first and last elements by their indices using comma operator\n",
    "t43[0],t43[-1] = t43[-1],t43[0]\n",
    "\n",
    "# Convert back list into tuple and Print the swaped tuple.\n",
    "print(f\"Tuple after swaping 1st and last element : {tuple(t43)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5da29a16-6b32-434e-94f4-08a72b09048b",
   "metadata": {},
   "source": [
    "## 44) Reverse the elements of a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2175a51f-80f9-48ca-b655-1e74d79a7e1b",
   "metadata": {},
   "source": [
    "## Ans 44)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a tuple.\n",
    "- Use built-in reversed() function to reverse the elements of tuple.\n",
    "- Reversed function Internally convert tuple into list and then reverse its element and return list of reversed element. So we have to convert its output into tuple to get the element in tuple data type.\n",
    "- Print the final reversed tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7bd85ece-fa5b-429b-8149-8a654e7fab54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (4, 5, 6, 7, 8) \n",
      "Reversed Tuple : (8, 7, 6, 5, 4)\n"
     ]
    }
   ],
   "source": [
    "# create/take a list.\n",
    "t44 = (4,5,6,7,8)\n",
    "print(f\"Given tuple : {t44} \")\n",
    "\n",
    "# Use reversed() function to reversed the elements of list and append each element to new list.    \n",
    "print(f\"Reversed Tuple : {tuple(reversed(t44))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c0d8ae-1712-4a05-9249-ff25ef1d94f6",
   "metadata": {},
   "source": [
    "## 45) Create a tuple of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76fbfd50-9864-45a3-89f1-93d1c74804c3",
   "metadata": {},
   "source": [
    "## Ans 45)\n",
    "\n",
    "#### Steps:\n",
    "- Take a value of n from user.\n",
    "- Create an empty list to store power of 2s.\n",
    "- Run the loop n times to calculate the first n power of 2 and append each value to empty list.\n",
    "- Convert empty list into tuple \n",
    "- Print the tuple of first n powers of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "01aa1ca0-c8f5-445a-996c-8445fb20c496",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the value of n :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of powers of 2 : (1, 2, 4, 8, 16)\n"
     ]
    }
   ],
   "source": [
    "# Take a value of n from user\n",
    "n = int(input(\"Enter the value of n : \"))\n",
    "\n",
    "# Create an empty list to store power of 2s.\n",
    "t45_empty = []\n",
    "\n",
    "# run the loop n times to calculate the n power of 2 and append each value to empty list.\n",
    "for i in range(n):\n",
    "    t45_empty.append(2**i)\n",
    "\n",
    "# print the list\n",
    "print(f\"Tuple of powers of 2 : {tuple(t45_empty)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0489543-ccd3-46b5-9455-e340272b73ff",
   "metadata": {},
   "source": [
    "## 46) Find the longest string in a tuple of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88e48c1d-e3eb-43e4-b647-213371d09d36",
   "metadata": {},
   "source": [
    "## Ans 46)\n",
    "\n",
    "#### Steps:\n",
    "- Create a tuple of words/strings.\n",
    "- Initialse a max_len variable by 0 and max_len_word by empty string.\n",
    "- Traverse through the tuple of words/string.\n",
    "- Update max_len and max_len_word, if current length of word is greater than previous word.\n",
    "- Print the longest string/word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "62249850-00c0-49a0-aafb-feaf4c4ef8bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple of strings is : ('You', 'are', 'very', 'beautifull', 'guy') \n",
      "Longest string in given tuple of strings is : beautifull \n"
     ]
    }
   ],
   "source": [
    "# create a tuple of strings\n",
    "t46 = ('You','are','very','beautifull','guy')\n",
    "\n",
    "max_len = 0\n",
    "max_len_word = ''\n",
    "for word in t46:\n",
    "    if len(word) > max_len:\n",
    "        max_len = len(word)\n",
    "        max_len_word = word\n",
    "\n",
    "\n",
    "print(f\"Given tuple of strings is : {t46} \\nLongest string in given tuple of strings is : {max_len_word} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbcfdf19-3b22-46fd-a851-635534dfb67c",
   "metadata": {},
   "source": [
    "## 47) Find the shortest string in a tuple of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2623ce3e-fd4e-4aa7-9dc6-8f588d54167f",
   "metadata": {},
   "source": [
    "## Ans 47)\n",
    "\n",
    "#### Steps:\n",
    "- Create a tuple of words/strings.\n",
    "- Initialse a min_len variable by very high value and min_len_word by empty string.\n",
    "- Traverse through the tuple of words/string.\n",
    "- Update min_len and min_len_word, if current length of word is less than previous word.\n",
    "- Print the shortest string/word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "556e01b9-b814-48e3-9845-710bdabf9cb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple of strings is : ['You', 'are', 'very', 'beautifull', 'guy'] \n",
      "Longest string in given tuple of strings is : You \n"
     ]
    }
   ],
   "source": [
    "# create a tuple of strings\n",
    "t47 = ['You','are','very','beautifull','guy']\n",
    "\n",
    "min_len = 99999\n",
    "min_len_word = ''\n",
    "for word in t47:\n",
    "    if len(word) < min_len :\n",
    "        min_len = len(word)\n",
    "        min_len_word = word\n",
    "\n",
    "\n",
    "print(f\"Given tuple of strings is : {t47} \\nLongest string in given tuple of strings is : {min_len_word} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e88b4fb8-051b-44f6-b9b2-bfb964b9d5ab",
   "metadata": {},
   "source": [
    "## 48) Create a tuple of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a91861f-f4cf-4734-b46f-b97d3d3dec30",
   "metadata": {},
   "source": [
    "## Ans 48)\n",
    "\n",
    "1) Triangular series : 1,3,6,10,15,21,....\n",
    "2) Formula : Tn = n(n+1)/2   ; gives the nth triangular term/number.\n",
    "\n",
    "#### Steps:\n",
    "- Take value of n from the user.\n",
    "- Generate n triangular numbers list by using formula.\n",
    "- Append each triangular number to empty list.\n",
    "- Convert empty list into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "658b126c-8a72-4632-8387-2b7d14987f75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n :  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of 7 triangular numbers : (1, 3, 6, 10, 15, 21, 28) \n"
     ]
    }
   ],
   "source": [
    "# Take value of n from the user.\n",
    "n = int(input(\"Enter value of n : \"))\n",
    "\n",
    "# create an empty list to store triangular numbers.\n",
    "t48_triangular_list = []\n",
    "\n",
    "# Generate n triangular numbers list by using formula.\n",
    "# Append each triangular number to empty list.\n",
    "for i in range(1,n+1):\n",
    "    Ti = int(i*(i+1)/2)\n",
    "    t48_triangular_list.append(Ti)\n",
    "    \n",
    "# Convert empty list into tuple and print it.\n",
    "print(f\"Tuple of {n} triangular numbers : {tuple(t48_triangular_list)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b733c092-0b53-4eef-9a15-9e6527e94b68",
   "metadata": {},
   "source": [
    "## 49) Check if a tuple contains another tuple as a subsequence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf9e001b-7dde-4c02-a6f4-d9b251073a99",
   "metadata": {},
   "source": [
    "## Ans 49)\n",
    "\n",
    "#### Steps:\n",
    "- Create/Take two tuples.\n",
    "- 1) Main tuple : In which subsequence to be search.\n",
    "- 2) Subsequence tuple : tuple to be seach in main tuple.\n",
    "- First of all search the 1st element of subsequence into main tuple, If 1st element exists in main list then only we will check other elements otherwise return/print main tuple does not contain another tuple as a subsequence.\n",
    "- If 1st element present in main tuple then find the index at which position the element is.\n",
    "- Once index is found we can slice the main tuple from that index, till length of subsequence.\n",
    "- If sliced tuple and another tuple are equal that means main tuple contains another tuple as a subsequence else main tuple does not contain another tuple as a subsequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3886c26a-ed38-4e58-9bec-9c92d0ba5abd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given Tuple : (1, 2, 3, 4, 5)\n",
      "Another Tuple : (2, 5) \n",
      "Tuple doesn't contain another Tuple as a subsequence.\n"
     ]
    }
   ],
   "source": [
    "t49_1= (1,2,3,4,5)\n",
    "t49_2 = (2,5)\n",
    "\n",
    "def subsequence(main_tuple,search_sequence):\n",
    "    for ele in search_sequence:\n",
    "        if ele not in main_tuple:\n",
    "            return print(f\"Tuple doesn't contain another tuple as a subsequence.\")\n",
    "        else:\n",
    "            for idx, element in enumerate(main_tuple):\n",
    "                if element == search_sequence[0]:\n",
    "                    if main_tuple[idx:idx+len(search_sequence)] == search_sequence[0:len(search_sequence)]:\n",
    "                        return print(f\"Tuple contains another tuple as a subsequence.\")\n",
    "                    else:\n",
    "                        return print(f\"Tuple doesn't contain another Tuple as a subsequence.\")\n",
    "\n",
    "                    \n",
    "print(f\"Given Tuple : {t49_1}\\nAnother Tuple : {t49_2} \")                    \n",
    "subsequence(t49_1, t49_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb4b461-70aa-428b-ba0e-e8f470e828ee",
   "metadata": {},
   "source": [
    "## 50) Create a tuple of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "501e3151-12d5-4993-ab96-a32371e75ebe",
   "metadata": {},
   "source": [
    "## Ans 50)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty list to store alternating 1s and 0s.\n",
    "- Take a value of n from user to create a tuple of alternating 1s and 0s of length n.\n",
    "- Run the loop n times.\n",
    "- In start list will be empty so start appending by 1.\n",
    "- If previous element in list is 1 then append next element as 0.\n",
    "- Convert list of 1s and 0s into tuple and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c3dab6d0-4117-4e30-8113-930f69cd7a2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n to create a tuple of alternating 1s and 0s :  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty list to store alternating 1s and 0s.\n",
    "t50 = []\n",
    "\n",
    "# take value of n form user.\n",
    "n = int(input(\"Enter value of n to create a tuple of alternating 1s and 0s : \"))\n",
    "\n",
    "# run the loop n times.\n",
    "for i in range(n):\n",
    "    if len(t50) == 0 or t50[i-1] == 0:    # In start list will be empty so start appending by 1\n",
    "        t50.append(1)\n",
    "    else:                                 # if previous element in list if 1 then append next element as 0\n",
    "        t50.append(0)\n",
    "        \n",
    "# convert list of 1s and 0s into tuple and print it\n",
    "print(f\"{tuple(t50)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b23ca5e-cc0c-4158-824c-0164e43a6a90",
   "metadata": {},
   "source": [
    "# ------------------ TOPIC : Set Based Assignment Problem --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ead356-7030-46fd-b4c4-4383cace13d9",
   "metadata": {},
   "source": [
    "## 1) Create a set with integers from 1 to 5.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f56b0762-9e6a-472d-ab50-5859c7b99bbe",
   "metadata": {},
   "source": [
    "## Ans 1)\n",
    "\n",
    "#### Steps:\n",
    "- To create a set with intergers from 1 to 5, inside a pair braces write all the value from 1 to 5 seperated by comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "33e278ce-b072-43c7-a4d6-f107d258b1bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A set with intergers from 1 to 5 : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "s1 = {1,2,3,4,5}\n",
    "\n",
    "print(f\"A set with intergers from 1 to 5 : {s1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c5a1bc-c8f3-45ca-8e3e-b9c04237cc08",
   "metadata": {},
   "source": [
    "## 2) Add an element to a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "906a0936-1304-45d6-a543-0bcba866d28b",
   "metadata": {},
   "source": [
    "## Ans 2)\n",
    "\n",
    "#### Steps:\n",
    "- Createa a set with elements.\n",
    "- Using add() function of set add an element to a set.\n",
    "- Print the final set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0b51e744-9331-41e8-b912-4869d0f1178f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set before adding an element : {1, 2, 3, 4, 5}\n",
      "Set after adding an element : {1, 2, 3, 4, 5, 'added element'}\n"
     ]
    }
   ],
   "source": [
    "# Createa a set with elements\n",
    "s2 = {1,2,3,4,5}\n",
    "print(f\"Set before adding an element : {s2}\")\n",
    "\n",
    "# using add() function of set add an element to a set\n",
    "s2.add('added element')\n",
    "\n",
    "# print the final set\n",
    "print(f\"Set after adding an element : {s2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edae70f6-12c8-4c7c-9000-0bd0273c9b69",
   "metadata": {},
   "source": [
    "## 3) Remove an element from a set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "166a4992-a566-4993-a7b2-d554f887edf9",
   "metadata": {},
   "source": [
    "## Ans 3)\n",
    "\n",
    "#### Steps:\n",
    "- Createa a set with elements.\n",
    "- Using remove() function of set remove an element from a set.\n",
    "- 1) remove() function takes an element that is to be remove from set.\n",
    "- 2) remove() function removes the given element from the set if it exists else it throughs error.\n",
    "- Print the set after removing an element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5a771b05-d4fe-43d1-ba91-8709e086e316",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {10, 12, 50, 30}\n",
      "Set after removing an element from it : {12, 50, 30}\n"
     ]
    }
   ],
   "source": [
    "# Createa a set with elements.\n",
    "s3 = {12,10,30,50}\n",
    "print(f\"Given set : {s3}\")\n",
    "\n",
    "# Using remove() function of set remove an element from a set.\n",
    "s3.remove(10)\n",
    "\n",
    "print(f\"Set after removing an element from it : {s3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a1da92-7ea3-4266-b495-83000f6d1c7f",
   "metadata": {},
   "source": [
    "## 4) Check if an element exists in a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f0dacd7-50a5-456b-8b82-52efe3247bf1",
   "metadata": {},
   "source": [
    "## Ans 4)\n",
    "\n",
    "#### Steps :\n",
    "- create/take a list.\n",
    "- Take an element from user to search in set.\n",
    "- By using 'in' operator search an element exists in a set or not.\n",
    "- If elements exists print element exists in a set else print element does not exist in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d0750b8d-3ad2-4c21-8473-f44e6cdf2ae5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set : {1, 2, 3, 4, 5, 6}\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an element to check wether it exists in a set or not :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 exists in given set : {1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set.\n",
    "s4 = {1,2,3,4,5,6}\n",
    "print(f\"Set : {s4}\")\n",
    "\n",
    "#Take an element from user to search in set.\n",
    "ele = int(input(\"Enter an element to check wether it exists in a set or not : \"))\n",
    "\n",
    "# By using 'in' operator search an element exists in a set or not.\n",
    "# If elements exists print element exists in a set else print element does not exist in a set.\n",
    "if ele in s4:\n",
    "    print(f\"{ele} exists in given set : {s4}\")\n",
    "else:\n",
    "    print(f\"{ele} does not exist in given set : {s4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0480a9c8-3bb5-40b8-9dcf-ac40425d4d81",
   "metadata": {},
   "source": [
    "## 5) Find the length of a set without using the `len()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c50425b1-2330-4c83-8ab6-5001e33d9e28",
   "metadata": {},
   "source": [
    "## Ans 5)\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a set.\n",
    "- Initialise a counter with 0, that will count the number of elements in set.\n",
    "- Traverse through the set.\n",
    "- Increase the counter by 1 for each element of the set.\n",
    "- Display the length i.e counter value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6e927c9c-dfae-4282-a350-d9a54832d2a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "Length of set is : 10 \n"
     ]
    }
   ],
   "source": [
    "# create/take a set.\n",
    "s5 = {1,2,3,4,5,6,7,8,9,10}\n",
    "\n",
    "# Initialise a counter with 0, that will count the number of elements in set.\n",
    "set_counter = 0\n",
    "\n",
    "# Traverse through the set.\n",
    "# Increase the counter by 1 for each element of the set.\n",
    "for ele in s5:\n",
    "    set_counter += 1\n",
    "    \n",
    "# Display the length i.e counter value. \n",
    "print(f\"Given set : {s5}\\nLength of set is : {set_counter} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20acb1b9-564f-4e68-be1e-b61d14abea5f",
   "metadata": {},
   "source": [
    "## 6) Clear all elements from a set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "943f8bdb-5b45-4b84-bdc9-72948d0064bc",
   "metadata": {},
   "source": [
    "## Ans 6)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elements\n",
    "- Use clear() function to remove all element from the set.\n",
    "- print set after removing all element form it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5045f7a6-8d11-4c2d-a1a6-10bbeb0a546f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 5, 6, 7, 8, 9} \n",
      "Set after removing all elemnts : set() \n"
     ]
    }
   ],
   "source": [
    "# create/take a set of elements\n",
    "s6 = {1,2,3,4,5,6,7,8,9}\n",
    "\n",
    "print(f\"Given set : {s6} \")\n",
    "# Use clear() function to remove all element of the set.\n",
    "s6.clear()\n",
    "\n",
    "# print set after removing all element form it\n",
    "print(f\"Set after removing all elemnts : {s6} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14561b7d-25f5-4c8f-9935-8023f47acd61",
   "metadata": {},
   "source": [
    "## 7) Create a set of even numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "872e57bd-114f-4f1b-a689-8b7d77f48216",
   "metadata": {},
   "source": [
    "## Ans 7)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty set to store all even numbers from 1 to 20 using set() function.\n",
    "- Generate a sequence of even numbers from 1 to 20 by using range() function.\n",
    "- In range() function, start from 2, take a positive jump of 2 till 21.\n",
    "- Add each number generated from range() function into empty set.\n",
    "- Print the set of even numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "614d579f-473f-4370-a6f2-1ab8025ecbd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even numbers from 1 to 20 : {2, 4, 6, 8, 10, 12, 14, 16, 18, 20} \n"
     ]
    }
   ],
   "source": [
    "# Create an empty set\n",
    "s7 = set()\n",
    "\n",
    "# Generate a sequence of numbers using range() function and add each generated even number into set\n",
    "# To get only even numbers, start from 2 till 20 and take a jump of 2\n",
    "for i in range(2,21,2):\n",
    "    s7.add(i)\n",
    "    \n",
    "# print set of even numbers\n",
    "print(f\"Set of even numbers from 1 to 20 : {s7} \") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "913dccd9-2688-419f-b170-c296fb7c608c",
   "metadata": {},
   "source": [
    "## 8) Create a set of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8166836-970e-49e8-9af3-5d7c8cd1fb29",
   "metadata": {},
   "source": [
    "## Ans 8)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty set to store all odd numbers from 1 to 20.\n",
    "- Generate a sequence of odd numbers from 1 to 20 by using range() function.\n",
    "- In range() function, start from 1, take a positive jump of 2 till 21.\n",
    "- Add each number generated from range() function into set.\n",
    "- Print the set of odd numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e662e046-3b1b-4124-8bb6-f9b6d1c1efa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd numbers from 1 to 20 : {1, 3, 5, 7, 9, 11, 13, 15, 17, 19} \n"
     ]
    }
   ],
   "source": [
    "# Create an empty set\n",
    "s8 = set()\n",
    "\n",
    "# Generate a sequence of numbers using range() function and append each generated odd number into set\n",
    "# To get only odd numbers, start from 1 till 20 and take a jump of 2\n",
    "for i in range(1,21,2):\n",
    "    s8.add(i)\n",
    "    \n",
    "# print set of even numbers\n",
    "print(f\"Set of odd numbers from 1 to 20 : {s8} \") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a76dd2-d90a-4f16-9bd3-9d5b2e7ba28e",
   "metadata": {},
   "source": [
    "## 9) Find the union of two sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e0f9f55-2a94-4dd3-bccf-372767b57d3b",
   "metadata": {},
   "source": [
    "## Ans 9) \n",
    "\n",
    "1) Union of two set : Union of two set is a set contains the elements which are present in either set 1 or in set 2.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's union() function find the union of two sets and print the final set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7e27c286-9697-40b3-bf7f-4ea25d80c4b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1 : {1, 2, 3, 4, 5, 6}\n",
      "Set 2 : {5, 6, 7}\n",
      "Union of two given sets is : {1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "# create/take two sets\n",
    "s9_1 = {1,2,3,4,5,6}\n",
    "s9_2 = {5,6,7}\n",
    "\n",
    "print(f\"Set 1 : {s9_1}\\nSet 2 : {s9_2}\\nUnion of two given sets is : {s9_1.union(s9_2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85582bf0-461c-4b11-b6ec-f10d9efa6225",
   "metadata": {},
   "source": [
    "## 10) Find the intersection of two sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69402f2e-38b6-4590-985e-23b94656451e",
   "metadata": {},
   "source": [
    "## Ans 10) \n",
    "\n",
    "1) Intersection of two set : Intersection of two set is a set contains the elements which are present in both the sets i.e set 1 and set 2.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's intersection() function find the intersection/common of two sets and print the final set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7f2394d5-a2ff-4c6a-a64b-055315a4c35a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1 : {1, 2, 3, 4, 5, 6}\n",
      "Set 2 : {5, 6, 7}\n",
      "Intersection of two given sets is : {5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s10_1 = {1,2,3,4,5,6}\n",
    "s10_2 = {5,6,7}\n",
    "\n",
    "# Using set's intersection() function find the intersection/common of two sets and print the final set. # \n",
    "print(f\"Set 1 : {s10_1}\\nSet 2 : {s10_2}\\nIntersection of two given sets is : {s10_1.intersection(s10_2)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e281ffa-d1f4-4f41-85f6-f01097aa0973",
   "metadata": {},
   "source": [
    "## 11) Find the difference between two sets.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce21b6b2-4bde-496e-acab-fb8db55a696b",
   "metadata": {},
   "source": [
    "## Ans 11) \n",
    "\n",
    "1) Difference between two sets : Let two sets A = {1,2,3,4,5} and B = {3,4,5,6,7,8}.\n",
    "- 1) Difference between A and B : A-B = {6,7,8} ; it returns a set containing values which are not in set B.\n",
    "- - In short : A-B returns a set of elements of A which are not in set B.\n",
    "- 2) Difference between B and A : B-A = {1,2} ; it returns a set containing values which are not in set A.\n",
    "- - In short : B-A returns a set of elements of B which are not in set A.\n",
    "- Note: Difference between two sets is used to find the values of a set which are not present in another set.\n",
    "\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's difference() function find the difference between two sets and print the final set. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "0917f1b7-6363-4d02-b79c-27210b80c62b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets: \n",
      "Set 1 : {1, 2, 3, 4, 5}\n",
      "Set 2 : {3, 4, 5, 6, 7, 8}\n",
      "Difference between set 1 and set 2 is : {1, 2}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s11_1 = {1,2,3,4,5}\n",
    "s11_2 = {3,4,5,6,7,8}\n",
    "\n",
    "print(f\"Given sets: \\nSet 1 : {s11_1}\\nSet 2 : {s11_2}\")\n",
    "# Using set's difference() function find the difference between two sets and print the final set. \n",
    "print(f\"Difference between set 1 and set 2 is : {s11_1.difference(s11_2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b79cc13-4127-4d9c-bc3f-bc81912751a0",
   "metadata": {},
   "source": [
    "## 12) Check if a set is a subset of another set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "247ef7c8-3a8c-4c1b-8edf-a39b61a2a97b",
   "metadata": {},
   "source": [
    "## Ans 12) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's issubset() function, check whether another set is a subset of main set or not.\n",
    "- issubset() return True if another set is a subset of main set else return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c89ba5e6-7a73-49d2-8f3b-aadf6b66c7c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3, 4, 5}\n",
      "Set 2 : {3, 4}\n",
      "Set 2 : {3, 4} is a subset of Set 1 : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s12_1 = {1,2,3,4,5}\n",
    "s12_2 = {3,4}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s12_1}\\nSet 2 : {s12_2}\")\n",
    "if s12_2.issubset(s12_1):\n",
    "    print(f\"Set 2 : {s12_2} is a subset of Set 1 : {s12_1}\")\n",
    "else:\n",
    "    print(f\"Set 2 : {s12_2} is not a subset of Set 1 : {s12_1}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37eb2d59-e386-4462-a2eb-6c3120e8a340",
   "metadata": {},
   "source": [
    "## 13) Check if a set is a superset of another set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d5ab67-9a64-4d1f-aa4e-9c4c2d675fc7",
   "metadata": {},
   "source": [
    "## Ans 13) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's issubset() function, check whether another set is a subset of main set or not.\n",
    "- issubset() return True if another set is a subset of main set else return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a3993b37-9656-4374-84eb-24904aaeaa3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3, 4, 5}\n",
      "Set 2 : {8, 3, 4}\n",
      "Set 1 : {1, 2, 3, 4, 5} is not a superset of Set 2 : {8, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s13_1 = {1,2,3,4,5}\n",
    "s13_2 = {3,4,8}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s13_1}\\nSet 2 : {s13_2}\")\n",
    "if s13_1.issuperset(s13_2):\n",
    "    print(f\"Set 1 : {s13_1} is a superset of Set 2 : {s13_2}\")\n",
    "else:\n",
    "    print(f\"Set 1 : {s13_1} is not a superset of Set 2 : {s13_2}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62df34b-b370-4748-81f8-b610b7115aa6",
   "metadata": {},
   "source": [
    "## 14) Create a set from a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaca2634-68a2-457e-8c79-fb9c6b842586",
   "metadata": {},
   "source": [
    "## Ans 14) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take a list.\n",
    "- Convert list into set using function set().\n",
    "- Print the converted set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ca5dffb8-ac24-4c0a-adb2-ca08417f451f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list : [1, 2, 3, 4, 5, 6]\n",
      "Converted Set : {1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a list.\n",
    "s14 = [1,2,3,4,5,6]\n",
    "print(f\"Given list : {s14}\")\n",
    "\n",
    "# Convert list into set using function set().\n",
    "# Print the converted set.\n",
    "print(f\"Converted Set : {set(s14)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "577871ef-0dbe-443e-b84c-082f18bdd3ec",
   "metadata": {},
   "source": [
    "## 15) Convert a set to a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ba92e1-f289-47fe-8b19-91fa3bdc67ed",
   "metadata": {},
   "source": [
    "## Ans 15) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elements.\n",
    "- Convert set into list using function list().\n",
    "- Print the converted list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8f99fcf8-327a-43c7-906b-0187e8979754",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 6}\n",
      "Converted list : [1, 2, 3, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of elements.\n",
    "s15 = {1,2,3,6,4}\n",
    "print(f\"Given set : {s15}\")\n",
    "\n",
    "# Convert set into list using function list().\n",
    "# Print the converted list.\n",
    "print(f\"Converted list : {list(s15)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2deccf3-e16c-4552-9541-503015f14b87",
   "metadata": {},
   "source": [
    "## 16) Remove a random element from a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30146a5d-e8af-47f7-af36-e3473be1d3ea",
   "metadata": {},
   "source": [
    "## Ans 16) \n",
    "\n",
    "1) To remove an element we can use remove or discard function. But to remove a random element we have to use pop() function that returns/remove random element from a set and raise error if set is empty.\n",
    "- Note: We know that set is unordered collection of data therefore pop() function remove any random element from a set.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elements.\n",
    "- Remove a random element from a set by using pop() function.\n",
    "- Print a set after removing element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "47f352f4-443f-42ed-b713-e6d82a753385",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 'data', 4.0, 6}\n",
      "Set after removing random element : {2, 'data', 4.0, 6}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of elements.\n",
    "s16 = {1,2,'data',6,4.0}\n",
    "print(f\"Given set : {s16}\")\n",
    "\n",
    "# Remove a random element from a set by using pop() function.\n",
    "s16.pop()\n",
    "\n",
    "# Print a set after removing element.\n",
    "print(f\"Set after removing random element : {s16}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4ecc854-8eb9-4191-92ad-5ad55d5ff9b4",
   "metadata": {},
   "source": [
    "## 17) Pop an element from a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29c99a6b-5d91-4456-9a37-9935d3dc4050",
   "metadata": {},
   "source": [
    "## Ans 17) \n",
    "\n",
    "1) pop() function returns/remove random element from a set and raise error if set is empty.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elements.\n",
    "- pop an element from a set by using pop() function and print that element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "05954bc7-4538-4bed-a6a1-b4a75c0b63d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 'data', 4.0, 6}\n",
      "Poped element from set : 1\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of elements.\n",
    "s16 = {1,2,'data',6,4.0}\n",
    "print(f\"Given set : {s16}\")\n",
    "\n",
    "# Remove a random element from a set by using pop() function.\n",
    "# Print a set after removing element.\n",
    "print(f\"Poped element from set : {s16.pop()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de4030c7-6802-4eed-b0e5-442917979e40",
   "metadata": {},
   "source": [
    "## 18) Check if two sets have no elements in common.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a04377c4-3ebf-490b-8a30-b2beae48f6ec",
   "metadata": {},
   "source": [
    "## Ans 18) \n",
    "\n",
    "1) We can check is there any common element in two sets or not by using intersection fucntion. How?\n",
    "2) If intersection function returns empty set that means there is no common element in both sets else there is/are common element(s) in both sets.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's intersection() function find the intersection/common of two sets \n",
    "- If there is no common element in both sets then print \"no common element in both sets\" else print \"there is/are common element(s) in both sets\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "f784e091-f8dd-4867-bc28-247df618c9e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3, 4, 5, 6}\n",
      "Set 2 : {8, 7}\n",
      "There is no common element in both sets\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s18_1 = {1,2,3,4,5,6}\n",
    "s18_2 = {7,8}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s18_1}\\nSet 2 : {s18_2}\")\n",
    "# Using set's intersection() function find the intersection/common of two sets\n",
    "# If there is no common element in both sets then print \"no common element in both sets\" else print \"there is/are common element(s) in both sets\".\n",
    "if len(s18_1.intersection(s18_2)) > 0 :\n",
    "    print(\"There is/are common element(s) in both sets\")\n",
    "    \n",
    "else:\n",
    "    print(\"There is no common element in both sets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f839562-d241-483a-a81d-792b09eb6cfd",
   "metadata": {},
   "source": [
    "## 19) Find the symmetric difference between two sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3203bce3-a606-47c6-a676-e7cfa59576eb",
   "metadata": {},
   "source": [
    "## Ans 19)\n",
    "\n",
    "1) Symmetric diffrence between two sets : Difference between their union and intersection.\n",
    "- Formula  => Symmetric difference between A and B = (A union B) - (A intersection B)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets of elments.\n",
    "- Find the symmetric difference between two sets using symmetric difference formula.\n",
    "- Print the symmetric difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3e6cded8-fbc5-4bd8-96bd-8e4276ef010b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets : \n",
      "Set 1 : {1, 2, 3}\n",
      "Set 2 : {3, 4, 5}\n",
      "Symmetric difference is : {1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets of elments.\n",
    "s19_1 = {1,2,3}\n",
    "s19_2 = {3,4,5}\n",
    "print(f\"Given sets : \\nSet 1 : {s19_1}\\nSet 2 : {s19_2}\")\n",
    "\n",
    "# Find the symmetric difference between two sets using symmetric difference formula.\n",
    "# Print the symmetric difference.\n",
    "print(f\"Symmetric difference is : {s19_1.union(s19_2).difference(s19_1.intersection(s19_2))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49cc375f-a09b-47b6-91f0-8b1985339a40",
   "metadata": {},
   "source": [
    "## 20)  Update a set with elements from another set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ba5e9d3-234f-4a91-8d29-7517f838413d",
   "metadata": {},
   "source": [
    "## Ans 20)\n",
    "\n",
    "1) By using Update() method we can update a set with elements from another set.\n",
    "2) update() method adds the elements of other set into a set.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets of elments.\n",
    "- Using update() function update the first set with another set's element.\n",
    "- Print the first update set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e4088b4a-e48a-49d3-8309-56baf66b25ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets : \n",
      "Set 1 : {1, 2, 3}\n",
      "Set 2 : {3, 4, 5}\n",
      "Updated set : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets of elments.\n",
    "s20_1 = {1,2,3}\n",
    "s20_2 = {3,4,5}\n",
    "print(f\"Given sets : \\nSet 1 : {s20_1}\\nSet 2 : {s20_2}\")\n",
    "\n",
    "# Using update() function update the first set with another set's element.\n",
    "s20_1.update(s20_2)\n",
    "\n",
    "# Print the first update set.\n",
    "print(f\"Updated set : {s20_1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "816a595a-c9a5-42c1-8c51-e9923f182233",
   "metadata": {},
   "source": [
    "## 21)  Create a set of the first 5 prime numbers.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06ab0bae-5769-4ac8-a730-9369b910893f",
   "metadata": {},
   "source": [
    "## Ans 21)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty set to store prime numbers\n",
    "- Run the loop from 2 to 51 to generate first 5 prime numbers\n",
    "- Check whether number is prime or not.\n",
    "- If number is prime then add it to empty set.\n",
    "- Print the set of prime numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d82cb126-8c17-43ae-8fc8-52bc18a72388",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of first 5 prime numbers : {2, 3, 5, 37, 7, 41, 11, 43, 13, 47, 17, 19, 23, 29, 31} \n"
     ]
    }
   ],
   "source": [
    "# create an empty set to store prime numbers\n",
    "s21 = set()\n",
    "\n",
    "# Run the loop from 2 to 51 to generate prime numbers\n",
    "# check whether number is prime or not.\n",
    "# if number is prime then append it.\n",
    "for i in range(2,51):\n",
    "    for j in range(2,i):\n",
    "        if i%j == 0:\n",
    "            break\n",
    "    else:\n",
    "        s21.add(i)\n",
    "    \n",
    "# print the set of prime numbers\n",
    "print(f\"Set of first 5 prime numbers : {s21} \")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c2d1b18-38d8-441e-8c4d-e4b43ade8531",
   "metadata": {},
   "source": [
    "## 22)  Check if two sets are identical.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c9caa90-8895-4a61-bc86-861ffe04add8",
   "metadata": {},
   "source": [
    "## Ans 22)\n",
    "\n",
    "#### Steps :\n",
    "- Create/Take two sets.\n",
    "- Using equal operator '==' compare both the sets.\n",
    "- Print Both sets are identical if condition is true else both are not identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "56ce5fb2-ae2d-49f9-8fcd-f427bdd701d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given Sets:\n",
      "Set 1 : {1, 2, 3}\n",
      "Set 2 : {1, 2, 3}\n",
      "Given sets are identical.\n"
     ]
    }
   ],
   "source": [
    "# create/Take two tuples.\n",
    "s22_1 = {1,2,3}\n",
    "s22_2 = {1,2,3}\n",
    "\n",
    "print(f\"Given Sets:\\nSet 1 : {s22_1}\\nSet 2 : {s22_2}\")\n",
    "\n",
    "# Using equal operator '==' compare both sets.\n",
    "# Print Both sets are identical if condition is true else both are not identical.\n",
    "if s22_1 == s22_2 :\n",
    "    print(\"Given sets are identical.\")\n",
    "else:\n",
    "    print(\"Given sets are not identical.\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bfcfab1-d8b1-43c2-9298-d3f428284ca3",
   "metadata": {},
   "source": [
    "## 23) Create a frozen set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e776cbf-42cb-4a09-9aee-4282c40ba1c5",
   "metadata": {},
   "source": [
    "## Ans 23)\n",
    "\n",
    "- A frozenset() function returns a frozenset object of the iterable passed to it.\n",
    "- The frozenset object is an immutable, unordered, set-like data type.\n",
    "- We can't assign items to a frozenset as it is an immutable data type (which can't be modified).\n",
    "- We can perform different set operations like \"copy\", \"difference\", \"union\", \"intersection\", and \"symmetric_difference\" on frozenset objects. \n",
    "\n",
    "#### Steps:\n",
    "- Create a list/set/string/tuple/dictionary.\n",
    "- Pass to frozenset() function , it return frozenset object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2f142ba2-7a2f-419f-b748-e8ab3f27a9d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created frozenset from list : frozenset({1, 2, 3, 4})\n"
     ]
    }
   ],
   "source": [
    "# Create a list/set/string/tuple/dictionary.\n",
    "s23 = [1,2,3,4]   # lets create a list of elements and pass it to frozenset() function.\n",
    "\n",
    "print(f\"Created frozenset from list : {frozenset(s23)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8331bca4-f9ae-421e-8956-87be15030774",
   "metadata": {},
   "source": [
    "## 24) Check if a set is disjoint with another set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84cc94ad-fa8b-41e3-9ea0-df652f02904e",
   "metadata": {},
   "source": [
    "## Ans 24)\n",
    "\n",
    "1) Disjoint means there is no common element between two sets or if the intersection between two sets is null/empty we say set is disjoint with another set.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets of elements.\n",
    "- By using isdisjoint() function of set, check whether a set is disjoint with another set or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9a19b56c-a8f8-42dc-b2f6-47e2a28b527f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets : \n",
      "Set 1 : {1, 2, 3, 4, 5}\n",
      "Set 2 : {6, 7, 8, 9, 10}\n",
      "Set is disjoint with another set.\n"
     ]
    }
   ],
   "source": [
    "s24_1 = {1,2,3,4,5}\n",
    "s24_2 = {6,7,8,9,10}\n",
    "\n",
    "print(f\"Given sets : \\nSet 1 : {s24_1}\\nSet 2 : {s24_2}\")\n",
    "if s24_1.isdisjoint(s24_2):\n",
    "    print(\"Set is disjoint with another set.\")\n",
    "else:\n",
    "    print(\"Set is not disjoint with another set.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d5579fd-fa00-4b9d-9397-15053807e5ab",
   "metadata": {},
   "source": [
    "## 25) Create a set of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "140085ac-d443-412d-8fff-ebcd9c7ba7c7",
   "metadata": {},
   "source": [
    "## Ans 25)\n",
    "\n",
    "#### Steps:\n",
    "- Create an empty set to store squares of numbers from 1 to 5.\n",
    "- Create a range of numbers from 1 to 5.\n",
    "- Add square of each number into set.\n",
    "- Print it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fd14e2df-cf21-4435-9c86-653755b2bbed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of sqaures of numbers from 1 to 5 : {1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "# create an empty Set to store squares of numbers from 1 to 5.\n",
    "s25 = set()\n",
    "\n",
    "# Create a range of numbers from 1 to 5.\n",
    "# Add square of each number into Set.\n",
    "for num in range(1,6):\n",
    "    s25.add(num*num)\n",
    "    \n",
    "# print it    \n",
    "print(f\"Set of sqaures of numbers from 1 to 5 : {s25}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c09a1cfc-9f8e-4894-b295-523ed73458e5",
   "metadata": {},
   "source": [
    "## 26) Filter out all even numbers from a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73f0c59d-9c19-42f8-b362-52502e7baad8",
   "metadata": {},
   "source": [
    "## Ans 26)\n",
    "\n",
    "#### Steps:\n",
    "- Create a set of even and odd numbers.\n",
    "- Create an empty set to store all even numbers.\n",
    "- Traverse through set and check element is even or not. \n",
    "- If element/number is even then append it into empty list.\n",
    "- Print set of all even numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "fac0a209-f55b-4f1c-b8ef-a10aeb4ded81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "Tuple of filtered out even numbers : {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "# Create a set of even and odd numbers.\n",
    "s26 = {1,2,3,4,5,6,7,8,9,10}\n",
    "\n",
    "# Create an empty set to store all even numbers.\n",
    "even_num_set = set()\n",
    "\n",
    "# Traverse through set and check element is even or not. \n",
    "# If element/number is even then append it into empty set.\n",
    "for num in s26:\n",
    "    if num%2 == 0:\n",
    "        even_num_set.add(num)\n",
    "# print it   \n",
    "print(f\"Given tuple : {s26}\\nTuple of filtered out even numbers : {even_num_set}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b90bbb78-9827-492d-beb6-8dfd0e7e61b6",
   "metadata": {},
   "source": [
    "## 27) Multiply all elements in a set by 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cd4816c-6706-483d-887c-845865660b16",
   "metadata": {},
   "source": [
    "## Ans 27)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of numbers.\n",
    "- Pass it to map function, and write a lambda function that multiply each element of set by 2.\n",
    "- Convert back the returned output of map function into set and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "71faa8fa-c19f-4ea6-863e-ff1c16d94313",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "Set, after multiplying each element by 2 : {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}\n"
     ]
    }
   ],
   "source": [
    "s27 = {1,2,3,4,5,6,7,8,9,10}\n",
    "print(f\"Given set : {s27}\")\n",
    "\n",
    "s27 = set(map(lambda x: x*2 ,s27))\n",
    "print(f\"Set, after multiplying each element by 2 : {s27}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cf0eda8-c621-4294-bea3-32628c80f14a",
   "metadata": {},
   "source": [
    "## 28) Create a set of random numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef703d3-45b6-4bc7-ba58-214d6c8c02b2",
   "metadata": {},
   "source": [
    "## Ans 28)\n",
    "\n",
    "#### Steps:\n",
    "- Import random module to generate a random number from given range.\n",
    "- Create an empty set to store random generated numbers.\n",
    "- Lets create a set of 10 random numbers by running the loop 10 times.\n",
    "- Add each randome generated number to the set.\n",
    "- Print the random generated set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "07f63caf-11cc-4528-8029-5d8d33518c56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of 10 random numbers : {3, 4, 6, 12, 14, 15, 17, 18} \n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "# lets generate a sequence of 10 random numbers\n",
    "s28 = set()\n",
    "\n",
    "# run the loop 10 times\n",
    "for i in range(10):\n",
    "    s28.add(random.randrange(1,20))\n",
    "    \n",
    "print(f\"Set of 10 random numbers : {s28} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e4bce94-f7e5-4976-a255-bda3705d57b9",
   "metadata": {},
   "source": [
    "## 29) Check if a set is empty."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d98f0f-aa01-41fb-9739-721cc0fcc19c",
   "metadata": {},
   "source": [
    "## Ans 29)\n",
    "\n",
    "#### Steps:\n",
    "- Using len() function we can check if a set is empty or not.\n",
    "- If length of a set is zero that means set is empty else not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "da68a980-5d55-42e6-b3d9-8d1f778b3291",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4} is not empty\n"
     ]
    }
   ],
   "source": [
    "# Create/taks a set\n",
    "s29 = {1,2,3,4}\n",
    "\n",
    "if len(s29) > 0:\n",
    "    print(f\"Given set : {s29} is not empty\")\n",
    "else:\n",
    "    print(f\"Given set : {s29} is empty\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e43d063-1c78-4e89-8346-515f6bffa539",
   "metadata": {},
   "source": [
    "## 30) Create a nested set (hint: use frozenset)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c940a50c-7eda-4e30-8ff3-407ae9a75c1b",
   "metadata": {},
   "source": [
    "## Ans 30)\n",
    "\n",
    "1) Nested set : When there is/are set(s) inside a main set then main set is called as 'Nested set'.\n",
    "2) Note: A Set can not contain mutable values like list,set. It can contain tuple or frozenset.\n",
    "\n",
    "#### Steps :\n",
    "- Create/take a set using pair of parentheses and call frozenset function and pass a set to it.\n",
    "- In this way we create a nested set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "438bfaa4-67ed-4934-8858-c0f9d3625feb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested set : {frozenset({8, 7})}\n"
     ]
    }
   ],
   "source": [
    "s30 = {frozenset({7,8})}\n",
    "\n",
    "print(f\"Nested set : {s30}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ad037a-5810-493c-9be2-88c999657a65",
   "metadata": {},
   "source": [
    "## 31) Remove an element from a set using the discard method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8149f283-e495-4ccb-b2a6-61e26785a1ad",
   "metadata": {},
   "source": [
    "## Ans 31)\n",
    "\n",
    "1) Discard() function removes a given element from a set if exists else ignore and doesn't through error.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elements.\n",
    "- By using discard function pass an element that is to be remove from set.\n",
    "- Print set after removing the element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d6597fd2-ef1c-4ab2-8dca-c301096eb475",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 5}\n",
      "Set after removing en element : {1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of elements.\n",
    "s31 = {1,2,3,4,5}\n",
    "\n",
    "print(f\"Given set : {s31}\")\n",
    "# By using discard function pass an element that is to be remove from set.\n",
    "s31.discard(3)\n",
    "\n",
    "# Print set after removing the element.\n",
    "print(f\"Set after removing en element : {s31}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa9d6b7-ac61-48e9-9f93-c77f1dd71f59",
   "metadata": {},
   "source": [
    "## 32) Compare two sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63890918-0127-4242-8ecb-1785224cc661",
   "metadata": {},
   "source": [
    "## Ans 32)\n",
    "\n",
    "1) We can perform different comparison task on two sets.\n",
    "2) For ex- Check whether two sets are equal to each other or not ?\n",
    "3) For ex- Check whether a set is greater/lesser than other set ? \n",
    "\n",
    "#### Steps :\n",
    "- Lets Check whether two sets are equal to each other or not?\n",
    "- create/Take two sets.\n",
    "- Using equal operator '==' compare both sets.\n",
    "- Print Both are equal if condition is true else both are not equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ff477d8b-2f97-4f70-aad3-e09766f09332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3}\n",
      "Set 2 : {0, 1, 3}\n",
      "Given sets are not equal.\n"
     ]
    }
   ],
   "source": [
    "# Lets Check whether two sets are equal to each other or not?\n",
    "# create/Take two sets.\n",
    "s32_1 = {1,2,3}\n",
    "s32_2 = {1,0,3}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s32_1}\\nSet 2 : {s32_2}\")\n",
    "# Using equal operator '==' compare both sets.\n",
    "# Print Both are equal if condition is true else both are not equal.\n",
    "if s32_1 == s32_2 :\n",
    "    print(\"Given sets are equal.\")\n",
    "else:\n",
    "    print(\"Given sets are not equal.\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b952cf0d-a1e7-410e-a28a-65dd4fb8bb22",
   "metadata": {},
   "source": [
    "## 33) Create a set from a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61b7fcb-c65b-4c73-8aca-5a08f715b9f1",
   "metadata": {},
   "source": [
    "## Ans 33)\n",
    "\n",
    "#### Steps:\n",
    "- create/take a string.\n",
    "- Convert string of characters into set of characters by typecaste it.\n",
    "- Print the converted set of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "25e0cf81-7d8f-4001-b165-08e57176bb81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string : datascience\n",
      "Created set from given string : {'a', 'i', 'e', 'c', 'n', 's', 'd', 't'}\n"
     ]
    }
   ],
   "source": [
    "# create/take string\n",
    "s33 = 'datascience'\n",
    "print(f\"Given string : {s33}\")\n",
    "\n",
    "print(f\"Created set from given string : {set(s33)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f19a5c5-42a7-4666-8f2d-6aa4b83eabbb",
   "metadata": {},
   "source": [
    "## 34) Convert a set of strings to a set of integers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51487fc-5437-44b5-ba61-e13d32443a10",
   "metadata": {},
   "source": [
    "## Ans 34)\n",
    "\n",
    "#### Steps:\n",
    "- create/take a set of strings.\n",
    "- Convert set of strings into set of integers by Using map function, pass set of strings to it and pass integer function to it.\n",
    "- Print the converted set of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a9cc058b-317d-4ed2-ae62-2fff71816a6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create/take a set of strings\n",
    "s34 = {'1','2','3','4'}\n",
    "print(f\"Set of strings : {s34}\")\n",
    "\n",
    "# Using map function, pass set of strings to it and pass integer function to it.\n",
    "print(f\"Set of intergers : {set(map(int,s34))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46bf25d7-4e14-4a04-b0c9-4423b6752da4",
   "metadata": {},
   "source": [
    "## 35) Convert a set of integers to a set of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e66dac9-6e09-4693-a105-f50cdde6e037",
   "metadata": {},
   "source": [
    "## Ans 35)\n",
    "\n",
    "#### Steps:\n",
    "-  Create/take a set of integers.\n",
    "- Convert set of integers into set of strings by Using map function, pass set of integers to it and pass str function to it.\n",
    "- Print the converted set of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dc63235f-7134-43cb-95a8-bfe7b73ddea8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of integers : {1, 2, 3, 4}\n",
      "Set of strings : {'4', '3', '1', '2'}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of integers\n",
    "s35 = {1, 2, 3, 4}\n",
    "print(f\"Set of integers : {s35}\")\n",
    "\n",
    "# Using map function, pass set of integers to it and pass strings function to it.\n",
    "print(f\"Set of strings : {set(map(str,s35))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556f35eb-1a18-4341-b60e-d87e78c4de0e",
   "metadata": {},
   "source": [
    "## 36) Create a set from a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4699a36f-023c-42ac-8b63-c04ab455acf3",
   "metadata": {},
   "source": [
    "## Ans 36)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a tuple of elments.\n",
    "- Convert tuple into set by type caste it.\n",
    "- Print the converted set of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a4f69338-887a-47b0-a74a-145294c1b62c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given tuple : (1, 2, 3, 4, 5)\n",
      "Created set from given tuple : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take a tuple of elments.\n",
    "s36 = (1,2,3,4,5)\n",
    "print(f\"Given tuple : {s36}\")\n",
    "\n",
    "# Convert tuple into set by type caste it.\n",
    "# Print the converted set of elements.\n",
    "print(f\"Created set from given tuple : {set(s36)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96cd7d43-e324-4ae5-bd45-f8ff0e7c5638",
   "metadata": {},
   "source": [
    "## 37) Convert a set to a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5aaccc4-c57a-4402-a973-510e46228a60",
   "metadata": {},
   "source": [
    "## Ans 37)\n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set of elments.\n",
    "- Convert set into tuple by type caste it.\n",
    "- Print the converted tuple of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "955a3879-0074-4f01-bd0e-f7bfb05f96a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {1, 2, 3, 4, 5}\n",
      "Created tuple from given set : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Create/take a set of elments.\n",
    "s37 = {1, 2, 3, 4, 5}\n",
    "print(f\"Given set : {s37}\")\n",
    "\n",
    "# Convert set into tuple by type caste it.\n",
    "# Print the converted tuple of elements.\n",
    "print(f\"Created tuple from given set : {tuple(s37)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86123b30-cffc-42bf-a6b1-624b7a047e4a",
   "metadata": {},
   "source": [
    "## 38) Find the maximum value in a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444c0835-f6c5-4794-b4b1-3dc991e73e54",
   "metadata": {},
   "source": [
    "## Ans 38)\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a set of elements.\n",
    "- Using max() function find the max value in a set and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3133882a-078b-4157-a000-a1cdcd3aa37f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {50, 20, 40, 10, 30}\n",
      "Maximum element in set is : 50\n"
     ]
    }
   ],
   "source": [
    "# create/Take a set.\n",
    "s38 = {10,20,30,40,50}\n",
    "\n",
    "# Using max() function find the max value in a set and print it.\n",
    "print(f\"Given set : {s38}\\nMaximum element in set is : {max(s38)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c3bb2f8-540b-46a2-b234-a7e5206f1b29",
   "metadata": {},
   "source": [
    "## 39) Find the minimum value in a set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7616be28-501e-4dbb-a158-985c60a10b22",
   "metadata": {},
   "source": [
    "## Ans 39)\n",
    "\n",
    "#### Steps :\n",
    "- create/Take a set of elements.\n",
    "- Using min() function find the min value in a set and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "670ef8f3-292b-4922-9885-1d6b95ae251f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given set : {50, 20, 40, 10, 30}\n",
      "Minimum element in set is : 10\n"
     ]
    }
   ],
   "source": [
    "# create/Take a set.\n",
    "s39 = {10,20,30,40,50}\n",
    "\n",
    "# Using min() function find the min value in a set and print it.\n",
    "print(f\"Given set : {s39}\\nMinimum element in set is : {min(s39)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "112b808b-3d6c-4919-8814-7b255792d49a",
   "metadata": {},
   "source": [
    "## 40) Create a set from user input."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54bef670-47c6-4c66-8692-3c5b0afe99ab",
   "metadata": {},
   "source": [
    "## Ans 40) \n",
    "\n",
    "#### Steps:\n",
    "- Take values from users using input function by displaying a message \"Enter the values of set separated by space : \" and store it into a varaible.\n",
    "- Using split function, convert strings into list of string.\n",
    "- Using map function convert this list of string into list of integers by passing int function to map() function.\n",
    "- Finally Convert the list of intergers returned from map function into set and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "da994352-6125-43b2-8177-590c63f6bfe3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the values of set separated by space :  1 2 3 4 5 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created set is : {1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# take input form user and store it into a variable.\n",
    "input_set_values = input(\"Enter the values of set separated by space : \")\n",
    "\n",
    "# convert input(string) into list of string, then convert list of string into list of integers then convert\n",
    "# list into set and print it\n",
    "print(f\"Created set is : {set(map(int,input_set_values.split()))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecc9d865-473e-4d67-95e8-6628a86746b3",
   "metadata": {},
   "source": [
    "## 41) Check if the intersection of two sets is empty."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b588ee9-c10b-47d2-a58d-8e7891b31c0a",
   "metadata": {},
   "source": [
    "## Ans 41) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's intersection() function find the intersection/common of two sets.\n",
    "- If there is no common element (that means intersection is empty) in both sets then print \"Intersection of given sets is empty\" else print \"Intersection of given sets is not empty\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "919f6d94-aec5-4cfe-8b6f-db75639cea48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3, 4, 5, 6}\n",
      "Set 2 : {8, 7}\n",
      "Intersection of given sets is empty\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s41_1 = {1,2,3,4,5,6}\n",
    "s41_2 = {7,8}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s41_1}\\nSet 2 : {s41_2}\")\n",
    "# Using set's intersection() function find the intersection/common of two sets\n",
    "# If there is no common element (that means intersection is empty) in both sets then print \n",
    "# \"Intersection of given sets is empty\" else print \"Intersection of given sets is not empty\".\n",
    "if len(s41_1.intersection(s41_2)) > 0 :\n",
    "    print(\"Intersection of given sets is not empty\")\n",
    "    \n",
    "else:\n",
    "    print(\"Intersection of given sets is empty\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eab8062-f124-45dc-9b36-ea5b3be5754f",
   "metadata": {},
   "source": [
    "## 42) Create a set of the first 5 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "863ed282-8078-44e1-a9f5-0daa2b0cd492",
   "metadata": {},
   "source": [
    "## Ans 42)\n",
    "\n",
    "1) Fibonacci series formula : F(n) = F(n-1) + F(n-2)\n",
    "\n",
    "#### Steps :\n",
    "- Initialise a fibonacci series list by first two numbers 0 and 1.\n",
    "- Generate a fibonacci series of 10 numbers using fibonacci formula and append next generated element to list.\n",
    "- Convert the list into set and Print the final fibonaccci series of 10 numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "23d1b21b-48b9-4579-b471-39d3e2559f77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of 10 fibonacci numbers is : {0, 1, 2, 3, 5} \n"
     ]
    }
   ],
   "source": [
    "# Initialise a fibonacci series by first two numbers 0 and 1.\n",
    "s42 = [0,1]\n",
    "\n",
    "# Generate a fibonacci series of 10 numbers using fibonacci formula and append next generated element to list.\n",
    "for i in range(2,6):\n",
    "    s42.append(s42[i-1] + s42[i-2])\n",
    "    \n",
    "# print the final fibonaccci series of 10 numbers.\n",
    "print(f\"Set of 10 fibonacci numbers is : {set(s42)} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae0ae1d1-093a-425c-ba53-e5c194b0f688",
   "metadata": {},
   "source": [
    "## 43) Remove duplicates from a list using sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f92be4-f92c-47eb-951b-37153919066f",
   "metadata": {},
   "source": [
    "## Ans 43)\n",
    "\n",
    "#### Steps:\n",
    "- Take/Create a list of duplicate elements.\n",
    "- Convert list into set by using set() function all the duplicate values will be removed automatically.\n",
    "- Print set without duplicate values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2f586bf8-81ff-4b21-ad81-e8af9bfef0ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given list of duplicate values : [1, 2, 2, 3, 5, 1, 6, 3, 3, 6]\n",
      "Set after removing duplicate values : {1, 2, 3, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Take/Create a list of duplicate elements.\n",
    "t43 = [1,2,2,3,5,1,6,3,3,6]\n",
    "print(f\"Given list of duplicate values : {t43}\")\n",
    "\n",
    "# Convert list into set by using set() function all the duplicate values will be removed automatically.\n",
    "# Print set without duplicate values.\n",
    "print(f\"Set after removing duplicate values : {set(t43)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97682ed9-d090-4d28-abc4-18229ccc9f0b",
   "metadata": {},
   "source": [
    "## 44) Check if two sets have the same elements, regardless of their count."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b05785e-8fd2-4ea4-9ce5-cfea9fc39fbd",
   "metadata": {},
   "source": [
    "## Ans 44)\n",
    "\n",
    "1) Set is a data type which is used to store unique collection of data.\n",
    "2) If we try to store duplicate values in a set, then set will remove duplicate values and will store only unique values.\n",
    "3) Note: If two sets are equal, we can say they have same elements.\n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets containg elements.\n",
    "- Using equal comparison opertor (==) check whether two sets are equal or not.\n",
    "- If both sets are equal, print two sets have same elements else they don't have same elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e67e56ad-e0f1-4b5f-a647-a955bcdbc944",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets : \n",
      "Set 1 : {1, 2, 3, 4, 5, 6, 7}\n",
      "Set 2 : {1, 2, 3, 4, 5, 6, 7}\n",
      "Both sets have same elements.\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets containg elements.\n",
    "s44_1 = {1,2,3,4,5,6,7}\n",
    "s44_2 = {7,6,1,2,4,3,5}\n",
    "\n",
    "print(f\"Given sets : \\nSet 1 : {s44_1}\\nSet 2 : {s44_2}\")\n",
    "# Using equal comparison opertor (==) check whether two sets are equal or not.\n",
    "# If both sets are equal, print two sets have same elements else they don't have same elements.\n",
    "if s44_1 == s44_2:\n",
    "    print(f\"Both sets have same elements.\")\n",
    "else:\n",
    "    print(f\"Sets don't have same elements.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fa87fe6-b504-4113-943b-442d774f1930",
   "metadata": {},
   "source": [
    "## 45) Create a set of the first `n` powers of 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c52a2221-d789-4699-bd7f-617cfd4aad85",
   "metadata": {},
   "source": [
    "## Ans 45)\n",
    "\n",
    "#### Steps:\n",
    "- Take a value of n from user.\n",
    "- Create an empty set to store power of 2s.\n",
    "- Run the loop n times to calculate the n power of 2 and append each value to empty list.\n",
    "- Print the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ef1f268e-8e84-4d5d-9511-3b3b73a5d910",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the value of n :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of powers of 2 : {1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "# Take a value of n from user\n",
    "n = int(input(\"Enter the value of n : \"))\n",
    "\n",
    "# Create an empty list to store power of 2s.\n",
    "s45 = set()\n",
    "\n",
    "# run the loop n times to calculate the n power of 2 and append each value to empty list.\n",
    "for i in range(n):\n",
    "    s45.add(2**i)\n",
    "\n",
    "# print the list\n",
    "print(f\"Set of powers of 2 : {s45}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24d34d0-5632-49dc-b4bc-140a726cd4dd",
   "metadata": {},
   "source": [
    "## 46) Find the common elements between a set and a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e582a95c-b707-4cb2-9679-824d59277626",
   "metadata": {},
   "source": [
    "## Ans 46) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take a set and a list.\n",
    "- Convert list into set.\n",
    "- Using set's intersection() function find the intersection/common of two sets. \n",
    "- Print the common elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "59abeef2-e411-417f-8862-51beab9274bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given\n",
      "Set  : {1, 2, 3, 4, 5, 6}\n",
      "List  : [2, 3, 7, 4]\n",
      "Common elements between set and list : {2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s46_1 = {1,2,3,4,5,6}\n",
    "s46_2 = [2,3,7,4]\n",
    "\n",
    "print(f\"Given\\nSet  : {s46_1}\\nList  : {s46_2}\")\n",
    "# Using set's intersection() function find the intersection/common of two sets\n",
    "# If there is no common element in both sets then print \"no common element in both sets\" else print \"there is/are common element(s) in both sets\".\n",
    "print(f\"Common elements between set and list : {s46_1.intersection(set(s46_2))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39c040b5-f2cf-448e-b395-07d7882d040d",
   "metadata": {},
   "source": [
    "## 47) Create a set of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43406aa1-8ee1-4169-9744-38578222a54f",
   "metadata": {},
   "source": [
    "## Ans 47)\n",
    "\n",
    "1) Triangular series : 1,3,6,10,15,21,....\n",
    "2) Formula : Tn = n(n+1)/2\n",
    "\n",
    "#### Steps:\n",
    "- Take value of n from the user.\n",
    "- Create an empty set.\n",
    "- Generate n triangular numbers set by using formula.\n",
    "- Add each triangular number to empty set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "497dfdd8-5358-4e92-825e-d686a73f0cea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter value of n :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Triangular list of 5 numbers : {1, 3, 6, 10, 15} \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter value of n : \"))\n",
    "\n",
    "s47 = set()\n",
    "for i in range(1,n+1):\n",
    "    Ti = int(i*(i+1)/2)\n",
    "    s47.add(Ti)\n",
    "    \n",
    "print(f\"Triangular set of {n} numbers : {s47} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8a00eb5-67cf-4857-9f37-671644e985df",
   "metadata": {},
   "source": [
    "## 48) Check if a set contains another set as a subset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4929d2ca-6207-463b-8acb-5d655f0b5961",
   "metadata": {},
   "source": [
    "## Ans 48) \n",
    "\n",
    "#### Steps:\n",
    "- Create/take two sets.\n",
    "- Using set's issubset() function, check whether another set is a subset of main set or not.\n",
    "- issubset() return True if another set is a subset of main set else return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fdc8c759-b874-470c-a25b-7045324e407c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets:\n",
      "Set 1 : {1, 2, 3, 4, 5}\n",
      "Set 2 : {3, 4}\n",
      "Set 2 : {3, 4} is a subset of Set 1 : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Create/take two sets.\n",
    "s48_1 = {1,2,3,4,5}\n",
    "s48_2 = {3,4}\n",
    "\n",
    "print(f\"Given sets:\\nSet 1 : {s48_1}\\nSet 2 : {s48_2}\")\n",
    "if s48_2.issubset(s48_1):\n",
    "    print(f\"Set 2 : {s48_2} is a subset of Set 1 : {s48_1}\")\n",
    "else:\n",
    "    print(f\"Set 2 : {s48_2} is not a subset of Set 1 : {s48_1}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf396276-a7fd-435c-994a-ace40b29f9d6",
   "metadata": {},
   "source": [
    "## 49) Create a set of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4643ca16-56b1-4911-95b5-86bf7044bdda",
   "metadata": {},
   "source": [
    "## Ans 49)\n",
    "\n",
    "1) Note: We know that a set is a data type which is used to store unique collection of data.\n",
    "2) For ex- If we create a set of 6 elements with alternative 1s and 0s i.e : {1,0,1,0,1,0} and store it in a variable and print it then it will display a set of only two unique elemenets i.e : {0,1} . Why ?\n",
    "- - Note: This is because 1 and 0 are repeated many times in set and set ignore/remove all the duplicate values and store only unique once.\n",
    "\n",
    "- - NOTE: Because of this reason we can't create a set of alternating 1s and 0s of length n. If we try to create it always will create a set of two elements i.e {0,1}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e2ffb82a-50ff-4309-9ba1-2057cd2711d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a set of alternative 1s and 0s of length 6.\n",
    "s49 = {1,0,1,0,1,0}\n",
    "s49"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f439b7b-d6bd-4c82-ae9a-dca81734afd7",
   "metadata": {},
   "source": [
    "## 50) Merge multiple sets into one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba49c5c-45c4-4fa2-96b4-5935a1eb5adb",
   "metadata": {},
   "source": [
    "## Ans 50)\n",
    "\n",
    "#### Steps:\n",
    "- Create a set in which you want to merge all other sets.\n",
    "- Create a list of all sets you want to merge in one set.\n",
    "- Run the loop to get one set and take union of it with main set and store the update set into main set.\n",
    "- Print the merges set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "b3fd35c9-2675-4349-a3a0-450ec2f4b3f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Main set in which all other sets to be merge : {1, 2, 3, 4, 5}\n",
      "List of sets : [{1, 2, 3}, {8, 6, 7}, {10, 2, 90}]\n",
      "Merges set : {1, 2, 3, 4, 5, 6, 7, 8, 10, 90}\n"
     ]
    }
   ],
   "source": [
    "# create a set in which you want to merge all other sets.\n",
    "s49_1 = {1,2,3,4,5}\n",
    "\n",
    "print(f\"Main set in which all other sets to be merge : {s49_1}\")\n",
    "# create a list of all sets you want to merge in one set.\n",
    "set_list = [{1,2,3},{6,7,8},{10,2,90}]\n",
    "\n",
    "print(f\"List of sets : {set_list}\")\n",
    "# run the loop to get one set and take union of it with main set and store the update set into main set\n",
    "for st in set_list:\n",
    "    s49_1 = s49_1.union(st)\n",
    "    \n",
    "\n",
    "# Print the merges set \n",
    "print(f\"Merges set : {s49_1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "071f439a-67c8-45ab-aa8d-d6847720e2a0",
   "metadata": {},
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}