Session-10-Strings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d925c316",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ============ part1==========================\n",
    "\n",
    "- Basic python\n",
    "\n",
    "- packges\n",
    "\n",
    "- conditional statements\n",
    "\n",
    "- try-excepetion\n",
    "\n",
    "- functions\n",
    "\n",
    "- for\n",
    "\n",
    "- while\n",
    "\n",
    "#=============== Part-2 ============================\n",
    "\n",
    "- Strings\n",
    "\n",
    "- lists\n",
    "\n",
    "- dictionary\n",
    "\n",
    "- tuple  =========== > home work \n",
    "\n",
    "- sets\n",
    "\n",
    "- file handling sessions      heart of the python\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "535ad9f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "string1='python'\n",
    "\n",
    "# string is in always quotes\n",
    "# either it is single quote or double quotes\n",
    "# red color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "982b44b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(string1)   # type : str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "722674de",
   "metadata": {},
   "outputs": [],
   "source": [
    "name ----- >variable      \n",
    "\"name\" ---- > string\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d017337",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c22e1242",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string2=\"python\"\n",
    "string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ad43bc7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7a00c4a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n"
     ]
    }
   ],
   "source": [
    "print(string2)\n",
    "# whenever you print the strings the output will print with out quotes\n",
    "# don't confuse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3416469e",
   "metadata": {},
   "source": [
    "- python will consider default as single quotes\n",
    "\n",
    "- whenever you print the strings the output will print with out quotes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc1bb5f9",
   "metadata": {},
   "source": [
    "$Doc-string$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b49420d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for every function call it is a better approach\n",
    "# mention about what is happening inside the function call\n",
    "# which means you will write some lines of information about the function call\n",
    "# this is called doc string\n",
    "\n",
    "# doc string : multi lines\n",
    "# which are in triple quotes\n",
    "\n",
    "# markdown approach is not .py files\n",
    "# comments using ash symbol is not good write up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e66465e",
   "metadata": {},
   "outputs": [],
   "source": [
    "  \"\"\"\n",
    "    delete kb is method to delete knwoledge base\n",
    "    arguments: path str, content  str\n",
    "    return: None\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "efdade46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "write your story\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6462be0f",
   "metadata": {},
   "source": [
    "**Highlight a specific word**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d03c1a9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# today im learning 'python'\n",
    "# python is highlighted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d006dd5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "im learning 'python'\n"
     ]
    }
   ],
   "source": [
    "string1=\"im learning 'python'\"\n",
    "print(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8771acdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "im learning \"python\"\n"
     ]
    }
   ],
   "source": [
    "string2='im learning \"python\"'\n",
    "print(string2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b879fd6",
   "metadata": {},
   "source": [
    "- type\n",
    "\n",
    "- len\n",
    "\n",
    "- max\n",
    "\n",
    "- min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6724e127",
   "metadata": {},
   "outputs": [],
   "source": [
    "string1=\"ppyython\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "52f8b783",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(string1)   # str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "54f689b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how many char  are there : p  y  t  h  o  n\n",
    "len(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2a9d9734",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "078c2f4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "51c9056e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112, 121, 116, 104, 111, 110)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('p'),ord('y'),ord('t'),ord('h'),ord('o'),ord('n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "8561c10c",
   "metadata": {},
   "outputs": [],
   "source": [
    "str1='hello'\n",
    "str2='python'\n",
    "str3=' ' # empty string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "1ae0362a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(str3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86679955",
   "metadata": {},
   "source": [
    "**concatination**\n",
    "\n",
    "- we can add multiple strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2933cd1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellopython'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1+str2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "ebdb216c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1+' '+str2   # hello python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "9c4c4ed8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1+str3+str2  # 'hello'+' '+'python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0209c1e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hello'+' '+'python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f595f3ff",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [45], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mstr1\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43mstr2\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "str1-str2   # we cant subtract the strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "eaeee78c",
   "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)",
      "Cell \u001b[1;32mIn [46], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mstr1\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mstr2\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
     ]
    }
   ],
   "source": [
    "str1*str2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "433c664b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str11='hello'\n",
    "str22=' python'\n",
    "str11+str22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5af33b39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellohellohello'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1*3  # str1+str1+str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4c681e3e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [50], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mstr1\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mstr2\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "str1/str2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d44447",
   "metadata": {},
   "source": [
    "### only string concatenation possible"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c325acdd",
   "metadata": {},
   "source": [
    "- basic syntax\n",
    "\n",
    "- type\n",
    "\n",
    "- len\n",
    "\n",
    "- max\n",
    "\n",
    "- min\n",
    "\n",
    "- concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7946a1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# many interview questions they will ask on strings and list\n",
    "# while creating logic you might use part-1/ conditions and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c744a1e",
   "metadata": {},
   "source": [
    "**Indexing**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ed2248dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "string1='python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "874844e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in python index start with zero\n",
    "# if i want to retrive the charcter then we go for index operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5de34237",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from the 'python' i need only 'p'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f9c04a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "p   y    t   h    o   n\n",
    "0   1    2   3    4   5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "665fd8ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "print(string1[0])\n",
    "print(string1[1])\n",
    "print(string1[2])\n",
    "print(string1[3])\n",
    "print(string1[4])\n",
    "print(string1[5]) \n",
    "\n",
    "# whenever i write 5,6 same lines ====== loops\n",
    "# print(string1[i])  i=0    end 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eef29698",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implement for loop and print the string cahracters using index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "097285b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "string1='python'\n",
    "for i in range(0,6):\n",
    "    print(string1[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "14ecdcb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Implement using while loop:  wrapper and insert \n",
    "string=\"python\"\n",
    "i=0\n",
    "while i<6:\n",
    "    print(string[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "28baced1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "v\n",
      "e\n",
      "r\n",
      "y\n",
      " \n",
      "i\n",
      "n\n",
      "t\n",
      "e\n",
      "r\n",
      "s\n",
      "t\n",
      "i\n",
      "n\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "string1='python is very intersting'\n",
    "print(len(string1))\n",
    "for i in range(0,len(string1)):  # for i in range(0,25)\n",
    "    print(string1[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "a9f25237",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the index of p is 0\n",
      "the index of y is 1\n",
      "the index of t is 2\n",
      "the index of h is 3\n",
      "the index of o is 4\n",
      "the index of n is 5\n"
     ]
    }
   ],
   "source": [
    "string1='good morning'\n",
    "# the index of g is 0\n",
    "# the index of o is 1\n",
    "str1=\"python\"\n",
    "i=0\n",
    "while i<len(str1):\n",
    "    print(\"the index of {} is {}\".format(str1[i],i))\n",
    "    i=i+1\n",
    "    \n",
    "# step-1 :  i=0   0!=7(True)  print   i=1\n",
    "# step-2:   i=1   1!=7(True)  print   i=2\n",
    "# step-3:   i=2   2!=7(True)  print   i=3\n",
    "# step-4:   i=3   3!=7(True)  print   i=4\n",
    "# step-5:   i=4   4!=7(True)  print   i=5\n",
    "# step-6:   i=5   5!=7(True)  print   i=6\n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "8492684c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the index of p is 0\n",
      "the index of y is 1\n",
      "the index of t is 2\n",
      "the index of h is 3\n",
      "the index of o is 4\n",
      "the index of n is 5\n"
     ]
    }
   ],
   "source": [
    "str1=\"python\"\n",
    "i=0\n",
    "while True:\n",
    "    print(\"the index of {} is {}\".format(str1[i],i))\n",
    "    i=i+1\n",
    "    if i==6:\n",
    "        break\n",
    "    \n",
    "# when i=6  str1[6]  not exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "bcb694c0",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [66], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m str1\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpython\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mstr1\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "str1=\"python\"\n",
    "str1[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41982fd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "think like compiler ====== >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d287a7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "-6  -5  -4   -3   -2   -1\n",
    "p   y    t    h    o    n\n",
    "0   1    2    3    4    5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "c61e4a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "string1='python'\n",
    "print(string1[-6])    # -6 is negative index 0 is postive index for p\n",
    "print(string1[-5])    # -5 is negative index 1 is postive index for y\n",
    "print(string1[-4])\n",
    "print(string1[-3])\n",
    "print(string1[-2])\n",
    "print(string1[-1])  # for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "353a69ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# length ======= postive value\n",
    "# if i want take hiegt of one person top to bottom  or bottom to top\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "5f99db68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index of p is 0\n",
      "The index of y is 1\n",
      "The index of t is 2\n",
      "The index of h is 3\n",
      "The index of o is 4\n",
      "The index of n is 5\n"
     ]
    }
   ],
   "source": [
    "string1='python'\n",
    "for i in range(0,len(string1)):\n",
    "    print(\"The index of {} is {}\".format(string1[i],i))\n",
    "    \n",
    "# the negative index of p is -6\n",
    "# the negative index of y is -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "8c2ab6f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# print -6 to -1  direction postivie\n",
    "# start=-6\n",
    "# direction= post\n",
    "# last= 0-1=-1\n",
    "\n",
    "#len(string1)=6  ========= >   -1*6= -1*len(string1)= -len(string)\n",
    "\n",
    "string1='python'\n",
    "for i in range(-len(string1),0):\n",
    "    print(string1[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "5bcb37a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the Letter p has +ve index 0 and -ve index -6\n",
      "the Letter y has +ve index 1 and -ve index -5\n",
      "the Letter t has +ve index 2 and -ve index -4\n",
      "the Letter h has +ve index 3 and -ve index -3\n",
      "the Letter o has +ve index 4 and -ve index -2\n",
      "the Letter n has +ve index 5 and -ve index -1\n"
     ]
    }
   ],
   "source": [
    "# the letter p has postive index is 0 and negative index is -6\n",
    "# the letter y has postive index is 1 and negative index is -5\n",
    "\n",
    "string1 = 'python'\n",
    "for i in range(0-len(string1),0):\n",
    "    print('the Letter {} has +ve index {} and -ve index {}'.format(string1[i],len(string1)+i,i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84722be5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "7c96ae2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the positive index of p is 0 negative index of is -19\n",
      "the positive index of y is 1 negative index of is -18\n",
      "the positive index of t is 2 negative index of is -17\n",
      "the positive index of h is 3 negative index of is -16\n",
      "the positive index of o is 4 negative index of is -15\n",
      "the positive index of n is 5 negative index of is -14\n",
      "the positive index of   is 6 negative index of is -13\n",
      "the positive index of i is 7 negative index of is -12\n",
      "the positive index of s is 8 negative index of is -11\n",
      "the positive index of   is 9 negative index of is -10\n",
      "the positive index of e is 10 negative index of is -9\n",
      "the positive index of n is 11 negative index of is -8\n",
      "the positive index of j is 12 negative index of is -7\n",
      "the positive index of o is 13 negative index of is -6\n",
      "the positive index of y is 14 negative index of is -5\n",
      "the positive index of a is 15 negative index of is -4\n",
      "the positive index of b is 16 negative index of is -3\n",
      "the positive index of l is 17 negative index of is -2\n",
      "the positive index of e is 18 negative index of is -1\n"
     ]
    }
   ],
   "source": [
    "str22=\"python is enjoyable\"\n",
    "for i in range(-len(str22),0):\n",
    "    print(\"the positive index of {} is {} negative index of is {}\".format(str22[i],(i+len(str22)),i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "3bdc15a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the letter p has + index 0 and -ve index -6\n",
      "the letter y has + index 1 and -ve index -5\n",
      "the letter t has + index 2 and -ve index -4\n",
      "the letter h has + index 3 and -ve index -3\n",
      "the letter o has + index 4 and -ve index -2\n",
      "the letter n has + index 5 and -ve index -1\n"
     ]
    }
   ],
   "source": [
    "str1=\"python\"\n",
    "ctr=len(str1)\n",
    "for i in range(-len(str1),0,1):\n",
    "    print(\"the letter {} has + index {} and -ve index {}\".format(str1[i],ctr+i,i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29bee4d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# itertae through postive index\n",
    "# itertae through negative index\n",
    "# iterate through both pos and neg\n",
    "\n",
    "# every one knows how to write for while\n",
    "# not able to do : you might miss logic : 30min 1hour \n",
    "# 15min ===== > search other codes wrong approach\n",
    "# extra effort : this prcatice is not enough\n",
    "# kindly spend more time\n",
    "# either you will or you will perfect\n",
    "\n",
    "# already know python c java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79d4d2ff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82a3dc7a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b210eda",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e39a8c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68286976",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3d5515d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}