String_Assignment_by_Kiran_Sonkamble.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6a6fb246",
   "metadata": {},
   "source": [
    ": Kiran Sonkamble :9880994453  :krnsonkamble3@gmail.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "28cde76e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2545578619696 <class 'str'> strg\n"
     ]
    }
   ],
   "source": [
    "#Declare a string and store it in a variable. \n",
    "\n",
    "a = 'strg'\n",
    "\n",
    "#Check the type and print the id of the same.a= \"strg\"\n",
    "print(id(a), type(a), a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ada2dbbd",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Which are valid/invalid strings\n",
    "1. 'This is Python class'\n",
    "valid\n",
    "\n",
    "2. \"This is Python class\"\n",
    "valid\n",
    "\n",
    "3. '''This is Python class'''\n",
    "valid\n",
    "\n",
    "4. \"\"\"This is Python class\"\"\"\n",
    "valid\n",
    "\n",
    "5. 'This is Python's class'\n",
    "invalid\n",
    "\n",
    "6. \"Learnbay provides \"Java\", \"Python\" classes\"\n",
    "invalid\n",
    "\n",
    "7. \"Learnbay provides 'Java', 'Python' classes\"\n",
    "valid\n",
    "\n",
    "8. \"This is Python's class\"\n",
    "valid\n",
    "\n",
    "9. \"\"\"Learnbay provides \"Java\", \"Python\" classes\"\"\"\n",
    "valid\n",
    "\n",
    "10. '''Learnbay provides \"Java\", \"Python\" classes'''\n",
    "valid\n",
    "\n",
    "11. '''Learnbay provides\n",
    "\"Java\", \"Python\" \n",
    "classes'''\n",
    "valid\n",
    "\n",
    "12. 'This is\n",
    "Python \n",
    "class'\n",
    "\n",
    "invalid\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "57baf254",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Although that way may not be obvious at first unless you're Dutch. Although that way may not be obvious at first unless you're Dutch.\n",
      "The Length of my_str is 66\n",
      "False\n",
      "id of my_str and my_str1 is same? - True\n",
      "Type of my_str is: <class 'str'>\n",
      "Type of my_str is: str\n"
     ]
    }
   ],
   "source": [
    "#Write the code to get the output mentioned below print statement\n",
    "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",
    "print(my_str, my_str1)\n",
    "\n",
    "#output:- The length of my_str is 66\n",
    "print(f\"The Length of my_str is {len(my_str)}\")\n",
    "\n",
    "\n",
    "#output:- id of my_str and my_str1 is same? - True\n",
    "print(my_str is my_str1)\n",
    "print(f\"id of my_str and my_str1 is same? - {my_str is not my_str1}\")\n",
    "\n",
    "\n",
    "#output:- Type of my_str is: str\n",
    "print(f\"Type of my_str is: {type(my_str)}\")\n",
    "\n",
    "print(f\"Type of my_str is: str\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "34a0c5df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my time is %a min and day {c}\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=33\n",
    "c=\"TMR\"\n",
    "\n",
    "print(\"my time is %a min and day {c}\",a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "65444095",
   "metadata": {},
   "outputs": [],
   "source": [
    "strr= \"This is python class\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7132c81a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strr.index('class')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6a786c08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Th', 's ', 's python class']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=strr.split(\"i\")\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e3698d43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is python class'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i\".join(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c825bfcf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'as'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strr[-3::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3c544c32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c nohtyp si sihT'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strr[-5::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d17b8dc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2205763101808 sahoo\n"
     ]
    }
   ],
   "source": [
    "a=\"sahoo\"\n",
    "print(id(a),a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d9e975e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2205763102000 hahoo\n"
     ]
    }
   ],
   "source": [
    "b=\"hahoo\"\n",
    "print(id(b),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2256d352",
   "metadata": {},
   "outputs": [],
   "source": [
    "v=kahoo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "694be3cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n"
     ]
    }
   ],
   "source": [
    "print(dir(dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c6fb6651",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hahoo'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "5e64a20e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.startswith('kh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f48ab9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4f4e9f0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab*ad*df*gh\n"
     ]
    }
   ],
   "source": [
    "b=['ab','ad','df','gh']\n",
    "print('*'.join(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "456888e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Indexing\n",
    "mr = \"Although 8 that way may not be obvious at first unless you're Dutch\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "583c828b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'a', 'a', 'a', 'a']\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e9d466e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'a', 'a', 'a', 'a']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ac = [x for x in mr if ('a'== x or 'A'==x)]\n",
    "ac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ad63075",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "515c5038",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c58d121",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "00797e87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mr.find('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "514b8ce7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first character in my_str is: A\n",
      "The first character in my_str is: h\n",
      "The character at index 10 in my_str is: c\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": [
    "#Indexing\n",
    "my_str = \"Although 8 that way may not be obvious at first unless you're Dutch\"\n",
    "#Write the code to get the output,instructions are mentioned below print statement. use indexing\n",
    "\n",
    "print(f\"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(f\"The first character in my_str is: {my_str[7]}\")\n",
    "#output:- The first character in my_str is: h\n",
    "#Note:- Use len() function.\n",
    "\n",
    "# print(my_str.find('c'))\n",
    "print(f\"The character at index 10 in my_str is: {my_str[65]}\")\n",
    "#output:- The character at index 10 in my_str is: c\n",
    "#Note:- Use positive indexing\n",
    "\n",
    "print(f\"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",
    "\n",
    "print(f\"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",
    "\n",
    "print(f\"The character in  my_str is: {my_str[9]}\")\n",
    "#output:- The character in my_str is: 8\n",
    "\n",
    "#Note:- Use positive index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "dcdb71ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have sliced: Although that way may not be obvious at first unless you're Dutch.\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch.\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch.\n",
      "You have sliced: Although that way may not be obvious at first unless you're Dutch.\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 tah,\n",
      "You have sliced: ess you.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Slicing\n",
    "my_str = \"Although that way may not be obvious at first unless you're Dutch.\"\n",
    "#Write the code to get the output,instructions are mentioned below print statement. use slicing\n",
    "print(f\"You have sliced: {my_str[: :]}\")\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(f\"You have sliced: {my_str[:len(my_str)]}\")\n",
    "#output:- 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",
    "\n",
    "\n",
    "print(f\"You have sliced: {my_str[: : 1]}\")\n",
    "#output:- You have sliced: Although that way may not be obvious at first unless you're Dutch.without begin and end but using step\n",
    "\n",
    "\n",
    "\n",
    "print(f\"You have sliced: {my_str[0: : 1]}\")\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(f\"You have sliced: {my_str[0:1:-1]}\")\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(f\"You have sliced: {my_str[: : 2]}\")\n",
    "#output:- You have sliced: Atog htwymyntb biu tfrtuls o'eDth\n",
    "\n",
    "\n",
    "print(f\"You have sliced: {my_str[: : 3]}\")\n",
    "#output:- You have sliced: Ahgttam tebo  r lsorDc\n",
    "\n",
    "\n",
    "print(f\"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(f\"You have sliced: {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(f\"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(f\"You have sliced: {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?\n",
    "\n",
    "\n",
    "print(f\"You have sliced: {my_str[-50: -57: -1]},\")\n",
    "#output:- You have sliced: yaw ta, Using begin, end and step.\n",
    "\n",
    "\n",
    "print(f\"You have sliced: {my_str[49:56]}.\")\n",
    "#output:- You have sliced: ess you. Using begin, end and step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "d888ba2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learnbay Python\n",
      "LearnbayLearnbayLearnbay\n"
     ]
    }
   ],
   "source": [
    "#Basic operation on string\n",
    "str1 = 'Learnbay'\n",
    "str2 = 'Python'\n",
    "\n",
    "#Write the code to get the output,instructions are mentioned below.\n",
    "#Output is: Learnbay Python\n",
    "print(str1, str2)\n",
    "\n",
    "\n",
    "print(\"Python\" + 12)\n",
    "#Error: TypeError: can only concatenate str (not \"int\") to str\n",
    "\n",
    "print(\"Learnbaay\" + 12.2)\n",
    "#Error: TypeError: can only concatenate str (not \"float\") to str\n",
    "\n",
    "\n",
    "\n",
    "#Find below Output\n",
    "#Output is: LearnbayLearnbayLearnbay\n",
    "print(str1*3)\n",
    "\n",
    "#Error: TypeError: can't multiply sequence by non-int of type 'float'\n",
    "print(str1*12.3)\n",
    "\n",
    "#Error: TypeError: can't multiply sequence by non-int of type 'str'\n",
    "print(str1*str2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bbd1a477",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [33]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#Indexing\u001b[39;00m\n\u001b[0;32m      2\u001b[0m m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mad\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mm\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mm\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
     ]
    }
   ],
   "source": [
    "#Indexing\n",
    "m = \"ad\"\n",
    "print(m*m)\n",
    "# TypeError: can't multiply sequence by non-int of type 'str'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "a24fcace",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Find below Output\n",
    "str1 = 'Python'\n",
    "str2 = 'Python'\n",
    "str3 = 'Python$'\n",
    "str4 = 'Python$'\n",
    "\n",
    "#print True by using identity operator between str1 and str2\n",
    "print(str1 is str2)\n",
    "\n",
    "#print False by using identity operator between str1 and str3\n",
    "print(str1 is str3)\n",
    "\n",
    "\n",
    "#print False by using identity operator between str4 and str3\n",
    "print(str4 is str3)\n",
    "\n",
    "\n",
    "#Check if P is available in str1 and print True by using membership operator\n",
    "print('P' in str1)\n",
    "\n",
    "#Check if $ is available in str3 and print True by using membership operator\n",
    "print('$' in str3)\n",
    "\n",
    "\n",
    "#Check if N is available in str3 and print False by using membership operator\n",
    "print('N' in str3)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3472026c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This', 'is', 'JAVA', 'class']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Complete the below code\n",
    "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",
    "\n",
    "# str1.replace('Python','Java')\n",
    "\n",
    "# str1[8:14]= 'Java'\n",
    "\n",
    "q = str1.split(\" \")\n",
    "# str1[2]='JAVA'\n",
    "# TypeError: 'str' object does not support item assignment\n",
    "\n",
    "type(q)\n",
    "q[2]='JAVA'\n",
    "type(str1)\n",
    "\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "711be7c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = 'A'\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "print(str1 >= str2)\n",
    "\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "print(str1 == str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "print(str1 != str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using comparison operator\n",
    "print(str1 > str2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "dfccb12b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = 'a'\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "print(str1 < str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "print(str1 != str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "print(str1 == str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using comparison operator\n",
    "print(str1 > str2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "270d4ceb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'A'\n",
    "str2 = '65'\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",
    "# print(str1 >= 65)\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "print(str1 >= str2)\n",
    "\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "print(str1 == str2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "ce08b122",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Python'\n",
    "str2 = 'Python'\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "print(str1 >= str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "print(str1 == str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "print(str1 != str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using comparison operator\n",
    "print(str1 > str2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "10ef4fef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Python'\n",
    "str2 = 'python'\n",
    "#Compare str1 and str2 and print True using comparison operator\n",
    "print(str1 < str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print True using equality operator\n",
    "print(str1 != str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using equality operator\n",
    "print(str1 == str2)\n",
    "\n",
    "\n",
    "#Compare str1 and str2 and print False using comparison operator\n",
    "print(str1 >= str2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "a77dd101",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Python\n",
      "Python\n",
      "False\n",
      "True\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(b and a)\n",
    "print(a or b)\n",
    "print(b or a)\n",
    "print(not a)\n",
    "print(not b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "ca99a6e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "True 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, not b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "e27e7a98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learnbay Python\n",
      "Python learnbay\n",
      "False 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, b and a)\n",
    "print(a or b, b or a)\n",
    "print(not a, not b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "c84d93a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "9\n",
      "9\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",
    "print(my_str.find('z'))\n",
    "# -1\n",
    "# print(my_str.index('z'))\n",
    "# ValueError: substring not found\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'))\n",
    "# ValueError: substring not found\n",
    "\n",
    "# print(my_str.index('the'))\n",
    "# ValueError: substring not found\n",
    "\n",
    "print(my_str.find('t', 9, 15))\n",
    "\n",
    "\n",
    "print(my_str.rfind('u'))\n",
    "\n",
    "\n",
    "print(my_str.rindex('u'))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "33262ca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "aq =\"Type    your favorate codi  ng language: \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "4618258f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Type your favorate codi  ng language: '"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aq.replace(\"  \",' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "021f21da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51c8ccef",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "c4de2f21",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [x for x in aq if x!= ' ']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "02a0b169",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Typeyourfavoratecodinglanguage:\n"
     ]
    }
   ],
   "source": [
    "print(''.join(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe5ce9db",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "3a37328b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Typeyourfavoratecodinglanguage:'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qq = aq.split()\n",
    "''.join(qq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2baa0a9d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "66495598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type your    favorate coding language:          lkn\n",
      "lkn\n",
      "lkn\n",
      "         lkn\n"
     ]
    }
   ],
   "source": [
    "#W A P which applies strip() method if any string, which will be taken from user, starts and ends with space, or applies \n",
    "#rrstrip() method if that string only ends with space or applies lstrip() method if that string only starts with a space.\n",
    "\n",
    "Num = input(\"Type your favorate coding language: \")\n",
    "print(Num.strip())\n",
    "#For example:-\n",
    "#input:- '    Python   '\n",
    "#output:- 'Python'\n",
    "\n",
    "print(Num.lstrip())\n",
    "#input:- '    Python'\n",
    "#output:- 'Python'\n",
    "\n",
    "print(Num.rstrip())\n",
    "#input:- 'Python   '\n",
    "#output:- 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "95f27bad",
   "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.lower())\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())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "92fbd5d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter you text here, please: khkh juguk kug\n",
      "Khkh Juguk Kug\n",
      "Khkh juguk kug\n"
     ]
    }
   ],
   "source": [
    "#Write the code which takes one string from user and if it starts with small case letter then convert it to corresponding \n",
    "txt = input(\"Enter you text here, please: \")\n",
    "print(txt.title())\n",
    "print(txt.capitalize())\n",
    "\n",
    "\n",
    "#capital letter otherwise if starts with capital letters then convert first character of every word in that string into capital.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "91acb6aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Take a string from user and check if it is:-\n",
    "#     1. alphanumeric\n",
    "print(txt.isalnum())\n",
    "\n",
    "#     2. alphabets\n",
    "print(txt.isalpha())\n",
    "\n",
    "#     3. digit\n",
    "print(txt.isdigit())\n",
    "\n",
    "#     4. all letters are in lower case\n",
    "print(txt.islower())\n",
    "\n",
    "\n",
    "#     5. all letters are in upper case\n",
    "print(txt.isupper())\n",
    "\n",
    "#     6. in title case\n",
    "print(txt.istitle())\n",
    "\n",
    "\n",
    "#     7. a space character\n",
    "print(txt.isspace())\n",
    "\n",
    "\n",
    "#     8. numeric\n",
    "print(txt.isnumeric())\n",
    "\n",
    "\n",
    "#     9. all number elements in string are decimal\n",
    "print(txt.isdecimal())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "edd3c85f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter valid identifier@kh\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#W A P which takes a string as an input and prints True if the string is valid identifier else returns False.\n",
    "\n",
    "tst=input(\"enter valid identifier\") \n",
    "print(tst.isidentifier()) \n",
    "\n",
    "#Sample Input:- 'abc', 'abc1', 'ab1c', '1abc', 'abc$', '_abc', 'if'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebd0c5dd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "ec01d33f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#What will be output of below code?\n",
    "s = chr(65) + chr(97)\n",
    "print(s.isprintable())   #prints num, alphabet, special char\n",
    "\n",
    "s = chr(27) + chr(97)\n",
    "print(s.isprintable())\n",
    "\n",
    "s = '\\n'\n",
    "print(s.isprintable())\n",
    "\n",
    "s = ''\n",
    "print(s.isprintable())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ccfa0615",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#What will be output of below code?\n",
    "my_string = '  '\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = 'Studytonight'\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = 'Study tonight'\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = 'Studytonight@123'\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = '°'\n",
    "print(my_string.isascii())\n",
    "\n",
    "my_string = 'ö'\n",
    "print(my_string.isascii())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "78eb2c28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The strings are equal.\n"
     ]
    }
   ],
   "source": [
    "#What will be the output of below code?\n",
    "firstString = \"der Fluß\"\n",
    "secondString = \"der Fluss\"\n",
    "\n",
    "if firstString.casefold() == secondString.casefold():\n",
    "    print('The strings are equal.')\n",
    "else:\n",
    "    print('The strings are not equal.')\n",
    "\n",
    "# It converts all the capital letters in to the small letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "f4830e0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'der fluss'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstString.casefold()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b0d053f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "18081506",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python**\n",
      "**Python\n",
      "**Python**\n",
      "**Python**\n"
     ]
    }
   ],
   "source": [
    "#Write the code to get below output\n",
    "#O/P 1:- python** (using ljust method)\n",
    "p='Python'\n",
    "\n",
    "print(p.ljust(8,\"*\"))\n",
    "\n",
    "#Write the code to get below output\n",
    "#O/P 1:- **python (using rjust method)\n",
    "print(p.rjust(8,'*'))\n",
    "\n",
    "#Write the code to get below output\n",
    "#O/P 1:- **python** (using rjust method)\n",
    "\n",
    "print(p.center(10,'*'))\n",
    "\n",
    "print(f\"{p.rjust(8,'*')}**\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "515a9e16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "#Write a Python program to find the length of the my_str:-\n",
    "print(len(my_str))\n",
    "\n",
    "#Input:- 'Write a Python program to find the length of the my_str'\n",
    "#Output:- 55\n",
    "\n",
    "print(len(my_str)-12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "21050f6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "#Write a Python program to find the total number of times letter 'p' is appeared in the below string:-\n",
    "pp = 'peter piper picked a peck of pickled peppers.'\n",
    "\n",
    "print(pp.count('p'))\n",
    "\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- 9\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "5a4ecc55",
   "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": [
    "#Write a Python Program, to print all the indexes of all occurences of letter 'p' appeared in the string:-\n",
    "\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- \n",
    "print(pp.index('p'))\n",
    "\n",
    "# 0\n",
    "print(pp.index('p',5))\n",
    "\n",
    "# 6\n",
    "print(pp.index('p',7))\n",
    "\n",
    "# 8\n",
    "print(pp.index('p',12))\n",
    "\n",
    "# 12\n",
    "print(pp.index('p',20))\n",
    "\n",
    "# 21\n",
    "print(pp.index('p',27))\n",
    "\n",
    "# 29\n",
    "print(pp.index('p',37))\n",
    "\n",
    "# 37\n",
    "print(pp.index('p',39))\n",
    "\n",
    "# 39\n",
    "print(pp.index('p',40))\n",
    "\n",
    "# 40\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "e6e7ce4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['peter', 'piper', 'picked', 'a', 'peck', 'of', 'pickled', 'peppers.']\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "print(pp.split())\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- ['peter', 'piper', 'picked', 'a', 'peck', 'of', 'pickled', 'peppers.']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "badf9dde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "peppers. pickled of peck a picked piper peter\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "\n",
    "pl= 'peter piper picked a peck of pickled peppers.'\n",
    "\n",
    "pl_r=pl.split()\n",
    "\n",
    "pl_r=reversed(pl_s)\n",
    "\n",
    "print(\"\".join(pl_s))\n",
    "\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- 'peppers. pickled of peck a picked piper peter'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "5a3bfb37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".sreppep delkcip fo kcep a dekcip repip retep\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "\n",
    "pl= 'peter piper picked a peck of pickled peppers.'\n",
    "\n",
    "pl_r=pl.split()\n",
    "\n",
    "# pl_r=reversed(pl_r)\n",
    "\n",
    "pl_r=\" \".join(pl_r)\n",
    "\n",
    "print(pl_r[::-1])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- '.sreppep delkcip fo kcep a dekcip repip retep'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "9672bb9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "peter piper picked a peck of pickled peppers.\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "\n",
    "\n",
    "pl= 'peter piper picked a peck of pickled peppers.'\n",
    "print(pl[::1])\n",
    "\n",
    "# pl_s=pl.split()\n",
    "\n",
    "# pl_s=reversed(pl_s)\n",
    "\n",
    "# pl_s=\" \".join(pl_s)\n",
    "# pl_s\n",
    "# print(pl_s[::-1])\n",
    "\n",
    "#Output:- 'retep repip dekcip a kcep fo delkcip .sreppep'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "736c894f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter Piper Picked A Peck Of Pickled Peppers.\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "\n",
    "print(pp.title())\n",
    "#Input:- 'peter piper picked a peck of pickled peppers.'\n",
    "#Output:- 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "5261d46c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter piper picked a peck of pickled peppers.\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output:-\n",
    "\n",
    "print(pp.capitalize())\n",
    "#Input:- 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "#Output:- 'Peter piper picked a peck of pickled peppers.'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "57e3eda0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29\n"
     ]
    }
   ],
   "source": [
    "#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:-\n",
    "\n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Pickl'\n",
    "print(my_str.find(sub_str))\n",
    "#Output:- 29\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f6437aae",
   "metadata": {},
   "source": [
    "#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 will print sub_str not found:-\n",
    "\n",
    "my_str = 'Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Peck'\n",
    "new_str = 'Peak'\n",
    "print(my_str.replace(sub_str,new_str))\n",
    "Output:- 'Peter Piper Picked A Pack Of Pickled Peppers.'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "9f7b7334",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******Peck Peck******\n"
     ]
    }
   ],
   "source": [
    "#Write a python program to find below output (implements rjust and ljust):-\n",
    "\n",
    "\n",
    "pp='Peter Piper Picked A Peck Of Pickled Peppers.'\n",
    "sub_str = 'Peck'\n",
    "print(sub_str.rjust(10,'*'),sub_str.ljust(10,'*'))\n",
    "\n",
    "# print(sub_str.center(47,'*'))\n",
    "#Output:- '*********************Peck********************'\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "2bde404f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for r in list(pp):\n",
    "    if 'Peck' == r:\n",
    "       print(r)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "966345ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peter\n",
      "Piper\n",
      "Picked\n",
      "A\n",
      "Peck\n",
      "Of\n",
      "Pickled\n",
      "Peppers.\n"
     ]
    }
   ],
   "source": [
    "`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "80b61738",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "*\n",
      "*\n",
      "*\n",
      "*\n",
      "*\n",
      "*\n",
      "*\n"
     ]
    }
   ],
   "source": [
    "a = pp.split()\n",
    "for r in a:\n",
    "    if 'Peak' == r:\n",
    "        print('r')\n",
    "    else:\n",
    "        print('*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "a2e21eaf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['*']"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "2b134463",
   "metadata": {},
   "outputs": [],
   "source": [
    "c=[]\n",
    "for i in a:\n",
    "    if i ==\"Peck\":\n",
    "            c.append(i)\n",
    "    else:\n",
    "        c.append('**')\n",
    "aq =''.join(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "54f27d9f",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2770662871.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Input \u001b[1;32mIn [203]\u001b[1;36m\u001b[0m\n\u001b[1;33m    [''.join(x) for x in a if x == 'Peck' '**' else i]\u001b[0m\n\u001b[1;37m                                               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "[''.join(x) for x in a if x == 'Peck' '**' else i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "68d89e5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "qq =[x if x== 'Peck' else '**' for x in a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "da474d24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'********Peck******'"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join(qq)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}