String_Assignment_25_09_Harish_Sundaralingam .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "19e2e099",
   "metadata": {},
   "source": [
    "# String Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df88ab96",
   "metadata": {},
   "source": [
    "### Question 1 \n",
    "Declare a string and store it in a variable. \n",
    "Check the type and print the id of the same.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7e84f315",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'> 1760548880112\n"
     ]
    }
   ],
   "source": [
    "a = 'This is string'\n",
    "print(type(a), id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec2f8cb7",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "Which are valid/invalid strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "352549ee",
   "metadata": {},
   "source": [
    "1. 'This is Python class' - <b>valid</b>\n",
    "\n",
    "2. \"This is Python class\" - <b>valid</b> \n",
    "\n",
    "3. '''This is Python class''' - <b>valid</b> \n",
    "\n",
    "4. \"\"\"This is Python class\"\"\" - <b>valid</b>\n",
    "\n",
    "5. 'This is Python's class' -  <b>invalid</b>\n",
    "\n",
    "6. \"Learnbay provides \"Java\", \"Python\" classes\" - <b>invalid</b>\n",
    "\n",
    "7. \"Learnbay provides 'Java', 'Python' classes\" - <b>valid</b>\n",
    "\n",
    "8. \"This is Python's class\" - <b>valid</b> \n",
    "\n",
    "9. \"\"\"Learnbay provides \"Java\", \"Python\" classes\"\"\" - <b>valid</b>\n",
    "\n",
    "10. '''Learnbay provides \"Java\", \"Python\" classes''' - <b>valid</b>\n",
    "\n",
    "11. '''Learnbay provides<br> \"Java\", \"Python\" <br> classes'''   -    <b>valid</b> \n",
    "\n",
    "12. 'This is<br>Python<br>class'  - <b>invalid</b> \n",
    "\n",
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b93c9e",
   "metadata": {},
   "source": [
    "### Question 3\n",
    "Write the code to get the output mentioned below print statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "360a52fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of my_str is  66\n",
      "id of my_str and my_str1 is same? -  False\n",
      "Type of my_str is:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "my_str = \"Although that way may not be obvious at first unless you're Dutch.\"\n",
    "my_str1 = \"Although that way may not be obvious at first unless you're Dutch.\"\n",
    "\n",
    "print('The length of my_str is ',len(my_str))\n",
    "#output:- The length of my_str is 66\n",
    "\n",
    "print('id of my_str and my_str1 is same? - ', (my_str is my_str1)) #check\n",
    "#output:- id of my_str and my_str1 is same? - False \n",
    "#its false as the string has space characters which doesn't follow object reusability\n",
    "\n",
    "print('Type of my_str is: ', type(my_str))\n",
    "#output:- Type of my_str is: str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "231c218d",
   "metadata": {},
   "source": [
    "### Question 4\n",
    "#### Indexing\n",
    "Write the code to get the output,instructions are mentioned below print statement. use indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "725d9add",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first character in my_str is: A\n",
      "The first character in my_str is: A\n",
      "The character at the index 10 in my_str is:  \n",
      "The last character in my_str is: h\n",
      "The last character in my_str is: h\n",
      "The character in my_str is: 8\n"
     ]
    }
   ],
   "source": [
    "my_str = \"Although 8 that way may not be obvious at first unless you're Dutch\"\n",
    "\n",
    "print(\"The first character in my_str is:\",my_str[0])\n",
    "#output:- The first character in my_str is: A\n",
    "#Note:- Use positive indexing\n",
    "\n",
    "print(\"The first character in my_str is:\", my_str[-len(my_str)]) \n",
    "#output:- The first character in my_str is: A\n",
    "#Note:- Use len() function.\n",
    "\n",
    "print('The character at the index 10 in my_str is:', my_str[10])\n",
    "#output:- The character at index 10 in my_str is: ' '\n",
    "#Note:- Use positive indexing\n",
    "\n",
    "print('The last character in my_str is:', my_str[-1])\n",
    "#output:- The last character in my_str is: h\n",
    "#Note:- Use negative indexing.\n",
    "\n",
    "print('The last character in my_str is:', my_str[len(my_str)-1])\n",
    "#output:- The last character in my_str is: h\n",
    "#Note:- Use len() function.\n",
    "\n",
    "print('The character in my_str is:',my_str[9]) #check\n",
    "#output:- The character in my_str is: 8\n",
    "#Note:- Use positive index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47b34a9c",
   "metadata": {},
   "source": [
    "### Question 5\n",
    "#### Slicing \n",
    "Write the code to get the output,instructions are mentioned below print statement. use slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1f4835f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have sliced: Although that way may not be obvious at first unless you're Dutch. Without begin, end and step\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch. with begin as 0 end using len and without step\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch. without begin and end but using step\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch. With begin, end and step\n",
      "You have sliced: \n",
      "You have sliced: Atog htwymyntb biu tfrtuls o'eDth\n",
      "You have sliced: Ahgttam tebo  r lsorDc\n",
      "You have sliced: .hctuD er'uoy sselnu tsrif ta suoivbo eb ton yam yaw taht hguohtlA\n",
      "You have sliced: .hctuD er'uoy sselnu tsrif ta suoivbo eb ton yam yaw taht hguohtlA\n",
      "You have sliced: .cu ruysen si asovoe o a a athuhl\n",
      "You have sliced: .cu ruysen si asovoe o a a athuhl\n",
      "\n",
      "You have sliced: yaw ta\n",
      "You have sliced: ess you\n"
     ]
    }
   ],
   "source": [
    "my_str = \"Although that way may not be obvious at first unless you're Dutch.\"\n",
    "\n",
    "print('You have sliced:',my_str[::],'Without begin, end and step')\n",
    "#output:- You have sliced: Although that way may not be obvious at first unless you're Dutch.Without begin, end and step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[0:len(my_str)+1],'with begin as 0 end using len and without step')\n",
    "#output:- You have sliced: Although that way may not be obvious at first unless you're Dutch.\n",
    "# with begin as 0 end using len and without step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[::1],'without begin and end but using step')\n",
    "#output:- You have sliced: Although that way may not be obvious at first unless you're Dutch.\n",
    "#without begin and end but using step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[0:len(my_str)+1:1],'With begin, end and step')\n",
    "#output:- You have sliced: Although that way may not be obvious at first unless you're Dutch.With begin, end and step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[2:15:-2])\n",
    "#output:- You have sliced:   .with using begin and end using postive values and step as negative values.\n",
    "#Slicing command should print empty string.\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[::2])\n",
    "#output:- You have sliced: Atog htwymyntb biu tfrtuls o'eDth\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[::3])\n",
    "#output:- You have sliced: Ahgttam tebo  r lsorDc\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[::-1])\n",
    "#output:- You have sliced: .hctuD er'uoy sselnu tsrif ta suoivbo eb ton yam yaw taht hguohtlA. Use only step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[-1:-len(my_str)-1:-1])\n",
    "#output:- You have sliced: .hctuD er'uoy sselnu tsrif ta suoivbo eb ton yam yaw taht hguohtlA. Use begin end and step.\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[::-2])\n",
    "#output:- You have sliced: .cu ruysen si asovoe o a a athuhl. use only step\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[-1:-len(my_str)-1:-2])\n",
    "#output:- You have sliced: .cu ruysen si asovoe o a a athuhl. use begin, end and step.\n",
    "\n",
    "\n",
    "print(my_str[10:17:-1])\n",
    "#What will be the output? - Empty string, if negative step is used start should be greater than stop (Right to left)\n",
    "\n",
    "\n",
    "print('You have sliced:',my_str[16:10:-1])\n",
    "#output:- You have sliced: yaw ta, Using begin, end and step.\n",
    "\n",
    "print('You have sliced:',my_str[-17:-10:1])\n",
    "#output:- You have sliced: ess you. Using begin, end and step.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcbe1bfd",
   "metadata": {},
   "source": [
    "### Question 6\n",
    "#### Basic operation on string\n",
    "Write the code to get the output,instructions are mentioned below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "818b8cff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learnbay Python\n",
      "LearnbayLearnbayLearnbay\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Learnbay'\n",
    "str2 = 'Python'\n",
    "\n",
    "\n",
    "print(str1 + \" \" + str2)\n",
    "#Output is: Learnbay Python\n",
    "\n",
    "# print(str1 + 5)\n",
    "#Error: TypeError: can only concatenate str (not \"int\") to str\n",
    "\n",
    "# print(str1 + 10.5)\n",
    "#Error: TypeError: can only concatenate str (not \"float\") to str\n",
    "\n",
    "print(str1 * 3)\n",
    "#Find below Output\n",
    "#Output is: LearnbayLearnbayLearnbay\n",
    "\n",
    "# print(str1 *10.5)\n",
    "#Error: TypeError: can't multiply sequence by non-int of type 'float'\n",
    "\n",
    "# print(str1 * str2)\n",
    "#Error: TypeError: can't multiply sequence by non-int of type 'str'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae3e7da5",
   "metadata": {},
   "source": [
    "### Question 7\n",
    "Find below Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d8b180db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Python'\n",
    "str2 = 'Python'\n",
    "str3 = 'Python$'\n",
    "str4 = 'Python$'\n",
    "\n",
    "print(str1 is str2)\n",
    "#print True by using identity operator between str1 and str2\n",
    "\n",
    "print(str1 is str3)\n",
    "#print False by using identity operator between str1 and str3\n",
    "\n",
    "print(str4 is str3)\n",
    "#print False by using identity operator between str4 and str3\n",
    "\n",
    "print(\"P\" in str1)\n",
    "#Check if P is available in str1 and print True by using membership operator\n",
    "\n",
    "print('$' in str3)\n",
    "#Check if $ is available in str3 and print True by using membership operator\n",
    "\n",
    "print('N' in str3)\n",
    "#Check if N is available in str3 and print False by using membership operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9216388b",
   "metadata": {},
   "source": [
    "### Question 8\n",
    "Complete the below code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b7ad3769",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-42-677176c2be0a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#TypeError: 'str' object does not support item assignment.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mstr1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m9\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m14\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'Java'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "str1 = 'This is Python class'\n",
    "#write the code to replace 'Python' with 'Java' and you should get below error.\n",
    "#TypeError: 'str' object does not support item assignment.\n",
    "str1[9:14] = 'Java'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c889990",
   "metadata": {},
   "source": [
    "### Question 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a39d8eba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = 'A'\n",
    "\n",
    "print(str1>=str2)\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "\n",
    "print(str1 == str2)\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "\n",
    "print(str1 != str2)\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "\n",
    "print(str1 < str2)\n",
    "#Compare str1 and str2 and print False using comparison operator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "911e18ea",
   "metadata": {},
   "source": [
    "### Question 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "83214ac8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = 'a'\n",
    "\n",
    "print(str1 < str2)\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "\n",
    "print(str1 != str2)\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "\n",
    "print(str1 == str2)\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "\n",
    "print(str1 > str2)\n",
    "#Compare str1 and str2 and print False using comparison operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "775d10ef",
   "metadata": {},
   "source": [
    "### Question 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "15fbb1ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = '65'\n",
    "\n",
    "# print(str >= int(str2))\n",
    "#Compare str1 and str2 using comparison operator and it should give below error.\n",
    "#Error: TypeError: '>=' not supported between instances of 'str' and 'int'\n",
    "\n",
    "print(str1 == chr(int(str2)))\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "\n",
    "print(str1 == str2)\n",
    "#Compare str1 and str2 and print False using equality operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "225fda86",
   "metadata": {},
   "source": [
    "### Question 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "9aa32287",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Python'\n",
    "str2 = 'Python'\n",
    "\n",
    "print(str1 >= str2)\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "\n",
    "print(str1 == str2)\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "\n",
    "print(str1 != str2)\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "\n",
    "print(str1 < str2)\n",
    "#Compare str1 and str2 and print False using comparison operator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbed1d06",
   "metadata": {},
   "source": [
    "### Question 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8798cd4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Python'\n",
    "str2 = 'python'\n",
    "\n",
    "print(str1 < str2)\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "\n",
    "print(str1 != str2)\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "\n",
    "print(str1 == str2)\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "\n",
    "print(str1 >= str2)\n",
    "#Compare str1 and str2 and print False using comparison operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50c76a3b",
   "metadata": {},
   "source": [
    "### Question 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "51495f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Python\n",
      "False\n",
      "True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = 'Python'\n",
    "b = ''\n",
    "\n",
    "#Apply logical opereators (and, or & not) on above string values and observe the output.\n",
    "print(a and b)\n",
    "print(a or b)\n",
    "print(not a)\n",
    "print(not b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64e10b1c",
   "metadata": {},
   "source": [
    "### Question 15\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "eb20f6aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = ''\n",
    "b = ''\n",
    "\n",
    "#Apply logical opereators (and, or & not) on above string values and observe the output.\n",
    "print(a and b)\n",
    "print(a or b)\n",
    "print(not a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "463519e9",
   "metadata": {},
   "source": [
    "### Question 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0a1791b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learnbay\n",
      "Python\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 'Python'\n",
    "b = 'learnbay'\n",
    "\n",
    "#Apply logical opereators (and, or & not) on above string values and observe the output.\n",
    "print(a and b)\n",
    "print(a or b)\n",
    "print(not a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8988bf7",
   "metadata": {},
   "source": [
    "### Question 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "868d038b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Find method 7\n",
      "Index method 7\n",
      "9\n",
      "9\n",
      "-1\n",
      "11\n",
      "63\n",
      "63\n"
     ]
    }
   ],
   "source": [
    "my_str = \"Although 8 that way may not be obvious at first unless you're Dutch\"\n",
    "\n",
    "#Write the code to get the total count of 't' in above string. Use find() and index() method.\n",
    "count = 0\n",
    "for i in my_str:\n",
    "    if i.find('t') > -1:\n",
    "        count += 1 \n",
    "print('Find method',count)\n",
    "\n",
    "count = 0\n",
    "k=0\n",
    "i=0\n",
    "l=my_str.rindex('t')\n",
    "while i<l:\n",
    "    i=my_str.index('t',i+1,len(my_str))\n",
    "    k=i\n",
    "    count+=1\n",
    "print('Index method',count)\n",
    "    \n",
    "#Write the code to get the index of '8' in my_str. Use find() and index() method.\n",
    "print(my_str.find('8'))\n",
    "print(my_str.index('8'))\n",
    "\n",
    "#What will be the output of below code?\n",
    "print(my_str.find('the'))  # - -1 as 'the' is not there in the string\n",
    "\n",
    "\n",
    "#print(my_str.index('the')) #- value error as 'the' is not there in the string\n",
    "\n",
    "\n",
    "print(my_str.find('t', 9, 15)) #- 11\n",
    "\n",
    "\n",
    "print(my_str.rfind('u')) #- 63\n",
    "\n",
    "\n",
    "print(my_str.rindex('u')) #- 63\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97bda9a9",
   "metadata": {},
   "source": [
    "### Question 18\n",
    "W A P which applies strip() method if any string, which will be taken from user, starts and ends with space, or applies \n",
    "rstrip() method if that string only ends with space or applies lstrip() method if that string only starts with a space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "685a7cd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:                  Python          \n",
      "Python\n"
     ]
    }
   ],
   "source": [
    "#For example:-\n",
    "#input:- '    Python   '\n",
    "#output:- 'Python'\n",
    "\n",
    "#input:- '    Python'\n",
    "#output:- 'Python'\n",
    "\n",
    "#input:- 'Python   '\n",
    "#output:- 'Python'\n",
    "\n",
    "my_str = input('Enter a string:')\n",
    "if my_str[0] == ' ' and my_str[-1] == ' ':\n",
    "    print(my_str.strip())\n",
    "elif my_str[-1] == ' ':\n",
    "    print(my_str.rstrip())\n",
    "elif my_str[0] == ' ':\n",
    "    print(my_str.lstrip())\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "474be153",
   "metadata": {},
   "source": [
    "### Question 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e07f2731",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ALTHOUGH 8 THAT WAY MAY NOT BE OBVIOUS AT FIRST UNLESS YOU'RE DUTCH\n",
      "although 8 that way may not be obvious at first unless you're dutch\n",
      "aLTHOUGH 8 THAT WAY MAY NOT BE OBVIOUS AT FIRST UNLESS YOU'RE dUTCH\n"
     ]
    }
   ],
   "source": [
    "my_str = \"Although 8 that way may not be obvious at first unless you're Dutch\"\n",
    "\n",
    "#Write the code to convert all alphabets in my_str into upper case.\n",
    "print(my_str.upper())\n",
    "\n",
    "#Write the code to convert all alphabets in my_str into lower case.\n",
    "print(my_str.casefold())\n",
    "\n",
    "#Write the code to swap the cases of all alphabets in my_str.(lower to upper and upper to lower)\n",
    "print(my_str.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ca05946",
   "metadata": {},
   "source": [
    "### Question 20\n",
    "Write the code which takes one string from user and if it starts with small case letter then convert it to corresponding \n",
    "capital letter otherwise if starts with capital letters then convert first character of every word in that string into capital.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "6a1b2b80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string:She sells seashells by the seashore\n",
      "She Sells Seashells By The Seashore\n"
     ]
    }
   ],
   "source": [
    "my_str = input('Please enter a string:')\n",
    "if my_str[0].islower() == True:\n",
    "    print(my_str.capitalize())\n",
    "elif my_str[0].isupper() == True:\n",
    "    print(my_str.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e17d0eec",
   "metadata": {},
   "source": [
    "### Question 21\n",
    "Take a string from user and check if it is:-\n",
    "1. alphanumeric\n",
    "2. alphabets\n",
    "3. digit\n",
    "4. all letters are in lower case\n",
    "5. all letters are in upper case\n",
    "6. in title case\n",
    "7. a space character\n",
    "8. numeric\n",
    "9. all number elements in string are decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "4dfd1f7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:AbvDEF457\n",
      "Is the string alphanumeric?  True\n",
      "Is the string alphabets?  False\n",
      "Is the string digit?  False\n",
      "Is all the letters in lower case?  False\n",
      "Is all the letters in upper case?  False\n",
      "Is the string in title case?  False\n",
      "Is the string a space character?  False\n",
      "Is the string numeric?  False\n",
      "Is the string decimal?  False\n"
     ]
    }
   ],
   "source": [
    "my_str = input('Enter a string:')\n",
    "print(\"Is the string alphanumeric? \",my_str.isalnum())\n",
    "print(\"Is the string alphabets? \",my_str.isalpha())\n",
    "print(\"Is the string digit? \",my_str.isdigit())\n",
    "print(\"Is all the letters in lower case? \",my_str.islower())\n",
    "print(\"Is all the letters in upper case? \",my_str.isupper())\n",
    "print(\"Is the string in title case? \",my_str.istitle())\n",
    "print(\"Is the string a space character? \",my_str.isspace())\n",
    "print(\"Is the string numeric? \",my_str.isnumeric())\n",
    "print(\"Is the string decimal? \",my_str.isdecimal())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e68a0c8",
   "metadata": {},
   "source": [
    "### Question 22\n",
    "W A P which takes a string as an input and prints True if the string is valid identifier else returns False.Sample Input:- 'abc', 'abc1', 'ab1c', '1abc', 'abc$', '_abc', 'if'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "e40d7f02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:1abc\n",
      "Is the string a valid identifier?  False\n"
     ]
    }
   ],
   "source": [
    "my_str = input('Enter a string:')\n",
    "print('Is the string a valid identifier? ',my_str.isidentifier())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50e39ff0",
   "metadata": {},
   "source": [
    "### Question 23\n",
    "What will be output of below code?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c55c1236",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "s = chr(65) + chr(97)\n",
    "print(s.isprintable()) # its Aa so printable \n",
    "\n",
    "s = chr(27) + chr(97) # char(27) is not a printable character \n",
    "print(s.isprintable())\n",
    "\n",
    "s = '\\n'\n",
    "print(s.isprintable()) #\\n is used for new line doesn't print in the print statement\n",
    "\n",
    "s = ''\n",
    "print(s.isprintable()) #printable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbfbdbf",
   "metadata": {},
   "source": [
    "### Question 24\n",
    "What will be output of below code?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "74aa5bdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "my_string = '  '\n",
    "print(my_string.isascii()) #space is in the ascii table \n",
    "\n",
    "my_string = 'Studytonight'\n",
    "print(my_string.isascii()) #alphabets are there in the ascii table\n",
    "\n",
    "my_string = 'Study tonight'\n",
    "print(my_string.isascii())#space and alphabets are there in the ascii table\n",
    "\n",
    "my_string = 'Studytonight@123' #space,@ and alphabets are there in the ascii table\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = '°'\n",
    "print(my_string.isascii()) #° is not in the ascii table hence false \n",
    "\n",
    "my_string = 'ö'\n",
    "print(my_string.isascii()) #ö is not in the ascii table hence false"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51131960",
   "metadata": {},
   "source": [
    "### Question 25\n",
    "What will be the output of below code?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "af1a6438",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The strings are equal.\n"
     ]
    }
   ],
   "source": [
    "firstString = \"der Fluß\"\n",
    "secondString = \"der Fluss\"\n",
    "\n",
    "if firstString.casefold() == secondString.casefold(): # when you casefold ß you get ss hence true statement is printed\n",
    "    print('The strings are equal.')\n",
    "else:\n",
    "    print('The strings are not equal.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b50ea80",
   "metadata": {},
   "source": [
    "### Question 26\n",
    "Write the code to get below output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1332d80f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python**\n",
      "**python\n",
      "**python**\n"
     ]
    }
   ],
   "source": [
    "#O/P 1:- python** (using ljust method)\n",
    "my_str = 'python'\n",
    "print(my_str.ljust(len(my_str)+2,\"*\"))\n",
    "\n",
    "\n",
    "#Write the code to get below output\n",
    "#O/P 1:- **python (using rjust method)\n",
    "print(my_str.rjust(len(my_str)+2,\"*\"))\n",
    "\n",
    "\n",
    "#Write the code to get below output\n",
    "#O/P 1:- **python** (using center method)\n",
    "print(my_str.center(len(my_str)+4,\"*\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9b2ae09",
   "metadata": {},
   "source": [
    "### Question 27\n",
    "Write a Python program to find the length of the my_str:-\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7b146fea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'Write a Python program to find the length of the my_str'\n",
    "my_str = 'Write a Python program to find the length of the my_str'\n",
    "print(len(my_str))\n",
    "#Output:- 55"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "555f281e",
   "metadata": {},
   "source": [
    "### Question 28\n",
    "Write a Python program to find the total number of times letter 'p' is appeared in the below string:-   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "9b60376d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "print(my_str.count('p'))\n",
    "#Output:- 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a97bda",
   "metadata": {},
   "source": [
    "### Question 29\n",
    "Write a Python Program, to print all the indexes of all occurences of letter 'p' appeared in the string:-\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "aa12ff54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "6\n",
      "8\n",
      "12\n",
      "21\n",
      "29\n",
      "37\n",
      "39\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "a = my_str.index('p')\n",
    "b = my_str.index('p',a+1)\n",
    "c = my_str.index('p',b+1)\n",
    "d = my_str.index('p',c+1)\n",
    "e = my_str.index('p',d+1)\n",
    "f = my_str.index('p',e+1)\n",
    "g = my_str.index('p',f+1)\n",
    "h = my_str.index('p',g+1)\n",
    "i = my_str.index('p',h+1)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)\n",
    "print(f)\n",
    "print(g)\n",
    "print(h)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc4af4ca",
   "metadata": {},
   "source": [
    "### Question 30\n",
    "Write a python program to find below output:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1b502e45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['peter', 'piper', 'picked', 'a', 'peck', 'of', 'pickled', 'peppers.']\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "print(my_str.split(' '))\n",
    "#Output:- ['peter', 'piper', 'picked', 'a', 'peck', 'of', 'pickled', 'peppers.']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0f4a71",
   "metadata": {},
   "source": [
    "### Question 31\n",
    "Write a python program to find below output:-\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "22bdf975",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "peppers. pickled of peck a picked piper peter\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "lst = list(my_str.split())\n",
    "new_lst =[]\n",
    "for i in range(-1,-len(lst)-1,-1):\n",
    "    new_lst = new_lst + [lst[i]] \n",
    "    \n",
    "print(\" \".join(new_lst))\n",
    "\n",
    "#Output:- 'peppers. pickled of peck a picked piper peter'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25583e29",
   "metadata": {},
   "source": [
    "### Question 32\n",
    "Write a python program to find below output:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0bf8cbd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".sreppep delkcip fo kcep a dekcip repip retep\n"
     ]
    }
   ],
   "source": [
    "# Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "print(my_str[::-1])\n",
    "#Output:- '.sreppep delkcip fo kcep a dekcip repip retep'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "206193f2",
   "metadata": {},
   "source": [
    "### Question 33\n",
    "Write a python program to find below output:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f60704db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " retep repip dekcip a kcep fo delkcip .sreppep\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "lst = my_str.split()\n",
    "new_str = ''\n",
    "for i in lst:\n",
    "    new_str = new_str + ' ' + i[::-1]\n",
    "print(new_str)\n",
    "\n",
    "#Output:- 'retep repip dekcip a kcep fo delkcip .sreppep'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f9ea56b",
   "metadata": {},
   "source": [
    "### Question 34\n",
    "Write a python program to find below output:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0854342c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter Piper Picked A Peck Of Pickled Peppers.\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "my_str = 'peter piper picked a peck of pickled peppers.'\n",
    "print(my_str.title())\n",
    "#Output:- 'Peter Piper Picked A Peck Of Pickled Peppers.'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6588a22",
   "metadata": {},
   "source": [
    "### Question 35\n",
    "Write a python program to find below output:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "66a6f8fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter piper picked a peck of pickled peppers.\n"
     ]
    }
   ],
   "source": [
    "#Input:-'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "print(my_str.capitalize())\n",
    "#Output:- 'Peter piper picked a peck of pickled peppers.'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25553ed4",
   "metadata": {},
   "source": [
    "### Question 36\n",
    "Write a python program to implement index method. If sub_str is found in my_str then it will print the index\n",
    "of first occurrence of first character of matching string in my_str:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d0415e81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29\n"
     ]
    }
   ],
   "source": [
    "# Input:- my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.', sub_str = 'Pickl'\n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Pickled'\n",
    "print(my_str.index(sub_str))\n",
    "#Output:- 29"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7094e6f2",
   "metadata": {},
   "source": [
    "### Question 37\n",
    "Write a python program to implement replace method. If sub_str is found in my_str then it will replace the first \n",
    "occurrence of sub_str with new_str else it will print sub_str not found:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5679584a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter Piper Picked A Pack Of Pickled Peppers.\n"
     ]
    }
   ],
   "source": [
    "#Input:- my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.', sub_str = 'Peck', new_str = 'Pack'\n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Peck'\n",
    "new_str = 'Pack'\n",
    "if my_str.find(sub_str) == -1 :\n",
    "    print('sub_str not found')\n",
    "else:\n",
    "    \n",
    "    print(my_str[0:my_str.find(sub_str)] + new_str + my_str[(my_str.find(sub_str)+len(sub_str)):len(my_str)])\n",
    "    \n",
    "#Output:- 'Peter Piper Picked A Pack Of Pickled Peppers.'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8db967df",
   "metadata": {},
   "source": [
    "### Question 38\n",
    "Write a python program to find below output (implements rjust and ljust):-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "baf801f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*********************Peck********************\n"
     ]
    }
   ],
   "source": [
    "#Input:- 'Peter Piper Picked A Peck Of Pickled Peppers.', sub_str = 'Peck', \n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Peck'\n",
    "new_str = sub_str.rjust((my_str.index(sub_str)+len(sub_str)),'*')\n",
    "final_str = new_str.ljust(len(my_str),'*')\n",
    "print(final_str)\n",
    "#Output:- '*********************Peck********************'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}