X3-Data-structures-II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are ordered text based data which are represented by enclosing the same in single/double/triple quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.913433Z",
     "iopub.status.busy": "2022-11-23T07:12:28.913214Z",
     "iopub.status.idle": "2022-11-23T07:12:28.917820Z",
     "shell.execute_reply": "2022-11-23T07:12:28.917510Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "String0 = 'Structural Geology is fun'\n",
    "String1 = \"Structural Geology is fun\"\n",
    "String2 = '''Structural Geology\n",
    "is\n",
    "fun'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.919595Z",
     "iopub.status.busy": "2022-11-23T07:12:28.919374Z",
     "iopub.status.idle": "2022-11-23T07:12:28.921659Z",
     "shell.execute_reply": "2022-11-23T07:12:28.921375Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structural Geology is fun <class 'str'>\n",
      "Structural Geology is fun <class 'str'>\n",
      "Structural Geology\n",
      "is\n",
      "fun <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(String0 , type(String0))\n",
    "print(String1, type(String1))\n",
    "print(String2, type(String2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String Indexing and Slicing are similar to Lists which was explained in detail earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.943579Z",
     "iopub.status.busy": "2022-11-23T07:12:28.943215Z",
     "iopub.status.idle": "2022-11-23T07:12:28.945808Z",
     "shell.execute_reply": "2022-11-23T07:12:28.945403Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n",
      "Geology is fun\n"
     ]
    }
   ],
   "source": [
    "print(String0[11])\n",
    "print(String0[11:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**find( )** function returns the index value of the given data that is to found in the string. If it is not found it returns **-1**. Remember to not confuse the returned -1 for reverse indexing value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.947626Z",
     "iopub.status.busy": "2022-11-23T07:12:28.947396Z",
     "iopub.status.idle": "2022-11-23T07:12:28.949496Z",
     "shell.execute_reply": "2022-11-23T07:12:28.949221Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "print(String0.find('Geo'))\n",
    "print(String0.find('Bio'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also input **find( )** function between which index values it has to search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.951223Z",
     "iopub.status.busy": "2022-11-23T07:12:28.950976Z",
     "iopub.status.idle": "2022-11-23T07:12:28.953059Z",
     "shell.execute_reply": "2022-11-23T07:12:28.952782Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(String0.find('u', 5))\n",
    "print(String0.find('u', 1, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**index( )** works the same way as **find( )** function the only difference is find returns '-1' when the input element is not found in the string but **index( )** function throws a ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.954691Z",
     "iopub.status.busy": "2022-11-23T07:12:28.954464Z",
     "iopub.status.idle": "2022-11-23T07:12:28.956579Z",
     "shell.execute_reply": "2022-11-23T07:12:28.956304Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(String0.index('u', 5))\n",
    "print(String0.index('u', 1, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**capitalize( )** is used to capitalize the first element in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.958288Z",
     "iopub.status.busy": "2022-11-23T07:12:28.958113Z",
     "iopub.status.idle": "2022-11-23T07:12:28.960044Z",
     "shell.execute_reply": "2022-11-23T07:12:28.959767Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observe the first letter in this sentence.\n"
     ]
    }
   ],
   "source": [
    "String3 = 'observe the first letter in this sentence.'\n",
    "print(String3.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**center( )** is used to center align the string by specifying the field width."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.961747Z",
     "iopub.status.busy": "2022-11-23T07:12:28.961528Z",
     "iopub.status.idle": "2022-11-23T07:12:28.966739Z",
     "shell.execute_reply": "2022-11-23T07:12:28.966467Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'                      Structural Geology is fun                       '"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0.center(70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also fill the left out spaces with any other character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.968435Z",
     "iopub.status.busy": "2022-11-23T07:12:28.968225Z",
     "iopub.status.idle": "2022-11-23T07:12:28.970547Z",
     "shell.execute_reply": "2022-11-23T07:12:28.970278Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'----------------------Structural Geology is fun-----------------------'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0.center(70, '-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**zfill( )** is used for zero padding by specifying the field width."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.972275Z",
     "iopub.status.busy": "2022-11-23T07:12:28.972030Z",
     "iopub.status.idle": "2022-11-23T07:12:28.974351Z",
     "shell.execute_reply": "2022-11-23T07:12:28.974081Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00000Structural Geology is fun'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0.zfill(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**expandtabs( )** allows you to change the spacing of the tab character. '\\t' which is by default set to 8 spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.976079Z",
     "iopub.status.busy": "2022-11-23T07:12:28.975842Z",
     "iopub.status.idle": "2022-11-23T07:12:28.977923Z",
     "shell.execute_reply": "2022-11-23T07:12:28.977641Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\te\tl\tl\to\n",
      "h e l l o\n",
      "h       e       l       l       o\n"
     ]
    }
   ],
   "source": [
    "s = 'h\\te\\tl\\tl\\to'\n",
    "print(s)\n",
    "print(s.expandtabs(2))\n",
    "print(s.expandtabs())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**endswith( )** function is used to check if the given string ends with the particular char which is given as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.979485Z",
     "iopub.status.busy": "2022-11-23T07:12:28.979366Z",
     "iopub.status.idle": "2022-11-23T07:12:28.981297Z",
     "shell.execute_reply": "2022-11-23T07:12:28.981012Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(String0.endswith('y'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The start and stop index values can also be specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.982970Z",
     "iopub.status.busy": "2022-11-23T07:12:28.982769Z",
     "iopub.status.idle": "2022-11-23T07:12:28.984803Z",
     "shell.execute_reply": "2022-11-23T07:12:28.984517Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(String0.endswith('n', 10))\n",
    "print(String0.endswith('M', 0, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**count( )** function counts the number of char in the given string. The start and the stop index can also be specified or left blank. (These are Implicit arguments which will be dealt in functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.986447Z",
     "iopub.status.busy": "2022-11-23T07:12:28.986273Z",
     "iopub.status.idle": "2022-11-23T07:12:28.988299Z",
     "shell.execute_reply": "2022-11-23T07:12:28.988018Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(String0.count('u', 0))\n",
    "print(String0.count('u', 5, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**join( )** function is used add a char in between the elements of the input string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.989954Z",
     "iopub.status.busy": "2022-11-23T07:12:28.989729Z",
     "iopub.status.idle": "2022-11-23T07:12:28.991662Z",
     "shell.execute_reply": "2022-11-23T07:12:28.991383Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g-e-o-l-o-g-y\n"
     ]
    }
   ],
   "source": [
    "c = '-'.join('geology')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`'geology'` is the input string and char `'-'` is added in between each element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**join( )** function can also be used to convert a list into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.993394Z",
     "iopub.status.busy": "2022-11-23T07:12:28.993167Z",
     "iopub.status.idle": "2022-11-23T07:12:28.995225Z",
     "shell.execute_reply": "2022-11-23T07:12:28.994945Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['S', 't', 'r', 'u', 'c', 't', 'u', 'r', 'a', 'l', ' ', 'G', 'e', 'o', 'l', 'o', 'g', 'y', ' ', 'i', 's', ' ', 'f', 'u', 'n']\n",
      "Structural Geology is fun\n"
     ]
    }
   ],
   "source": [
    "a = list(String0)\n",
    "print(a)\n",
    "b = ''.join(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**split( )** function is used to convert a string back to a list. Think of it as the opposite of the **join()** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:28.996833Z",
     "iopub.status.busy": "2022-11-23T07:12:28.996653Z",
     "iopub.status.idle": "2022-11-23T07:12:28.998577Z",
     "shell.execute_reply": "2022-11-23T07:12:28.998297Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['g', 'e', 'o', 'l', 'o', 'g', 'y']\n"
     ]
    }
   ],
   "source": [
    "d = c.split('-')\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In **split( )** function one can also specify the number of times you want to split the string or the number of elements the new returned list should conatin. The number of elements is always one more than the specified number this is because it is split the number of times specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.000250Z",
     "iopub.status.busy": "2022-11-23T07:12:29.000039Z",
     "iopub.status.idle": "2022-11-23T07:12:29.002094Z",
     "shell.execute_reply": "2022-11-23T07:12:29.001811Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['g', 'e', 'o', 'l-o-g-y']\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "e = c.split('-' ,3)\n",
    "print(e)\n",
    "print(len(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**lower( )** converts any capital letter to small letter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.003800Z",
     "iopub.status.busy": "2022-11-23T07:12:29.003578Z",
     "iopub.status.idle": "2022-11-23T07:12:29.005503Z",
     "shell.execute_reply": "2022-11-23T07:12:29.005219Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structural Geology is fun\n",
      "structural geology is fun\n"
     ]
    }
   ],
   "source": [
    "print(String0)\n",
    "print(String0.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**upper( )** converts any small letter to capital letter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.007234Z",
     "iopub.status.busy": "2022-11-23T07:12:29.007013Z",
     "iopub.status.idle": "2022-11-23T07:12:29.009245Z",
     "shell.execute_reply": "2022-11-23T07:12:29.008978Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'STRUCTURAL GEOLOGY IS FUN'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**replace( )** function replaces the element with another element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.010947Z",
     "iopub.status.busy": "2022-11-23T07:12:29.010734Z",
     "iopub.status.idle": "2022-11-23T07:12:29.013026Z",
     "shell.execute_reply": "2022-11-23T07:12:29.012745Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Structural Geology is boring'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0.replace('fun','boring')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**strip( )** function is used to delete elements from the right end and the left end which is not required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.014706Z",
     "iopub.status.busy": "2022-11-23T07:12:29.014523Z",
     "iopub.status.idle": "2022-11-23T07:12:29.016229Z",
     "shell.execute_reply": "2022-11-23T07:12:29.015950Z"
    }
   },
   "outputs": [],
   "source": [
    "f = '    hello      '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no char is specified then it will delete all the spaces that is present in the right and left hand side of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.017906Z",
     "iopub.status.busy": "2022-11-23T07:12:29.017691Z",
     "iopub.status.idle": "2022-11-23T07:12:29.019956Z",
     "shell.execute_reply": "2022-11-23T07:12:29.019685Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**strip( )** function, when a char is specified then it deletes that char if it is present in the two ends of the specified string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.021632Z",
     "iopub.status.busy": "2022-11-23T07:12:29.021427Z",
     "iopub.status.idle": "2022-11-23T07:12:29.023158Z",
     "shell.execute_reply": "2022-11-23T07:12:29.022870Z"
    }
   },
   "outputs": [],
   "source": [
    "f = '   ***----hello---*******     '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.024778Z",
     "iopub.status.busy": "2022-11-23T07:12:29.024597Z",
     "iopub.status.idle": "2022-11-23T07:12:29.026839Z",
     "shell.execute_reply": "2022-11-23T07:12:29.026557Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   ***----hello---*******     '"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.strip('*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The asterisk had to be deleted but is not. This is because there is a space in both the right and left hand side. So in strip function. The characters need to be inputted in the specific order in which they are present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.028508Z",
     "iopub.status.busy": "2022-11-23T07:12:29.028289Z",
     "iopub.status.idle": "2022-11-23T07:12:29.030263Z",
     "shell.execute_reply": "2022-11-23T07:12:29.029985Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----hello---\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(f.strip(' *'))\n",
    "print(f.strip(' *-'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**lstrip( )** and **rstrip( )** function have the same functionality as strip function but the only difference is **lstrip( )** deletes only towards the left side and **rstrip( )** towards the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.032030Z",
     "iopub.status.busy": "2022-11-23T07:12:29.031773Z",
     "iopub.status.idle": "2022-11-23T07:12:29.033778Z",
     "shell.execute_reply": "2022-11-23T07:12:29.033498Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----hello---*******     \n",
      "   ***----hello---\n"
     ]
    }
   ],
   "source": [
    "print(f.lstrip(' *'))\n",
    "print(f.rstrip(' *'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are more used like a database because here you can index a particular sequence with your user defined string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To define a dictionary, equate a variable to { } or dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.035649Z",
     "iopub.status.busy": "2022-11-23T07:12:29.035436Z",
     "iopub.status.idle": "2022-11-23T07:12:29.037507Z",
     "shell.execute_reply": "2022-11-23T07:12:29.037218Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'> <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "d0 = {}\n",
    "d1 = dict()\n",
    "print(type(d0), type(d1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary works somewhat like a list but with an added capability of assigning it's own index style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.039283Z",
     "iopub.status.busy": "2022-11-23T07:12:29.039031Z",
     "iopub.status.idle": "2022-11-23T07:12:29.041054Z",
     "shell.execute_reply": "2022-11-23T07:12:29.040774Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Azi': 124, 'Inc': 56}\n"
     ]
    }
   ],
   "source": [
    "d0['Azi'] = 124\n",
    "d0['Inc'] = 56 \n",
    "print(d0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is how a dictionary looks like. Now you are able to access '1' by the index value set at 'One'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.042824Z",
     "iopub.status.busy": "2022-11-23T07:12:29.042584Z",
     "iopub.status.idle": "2022-11-23T07:12:29.044505Z",
     "shell.execute_reply": "2022-11-23T07:12:29.044225Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124\n"
     ]
    }
   ],
   "source": [
    "print(d0['Azi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**clear( )** function is used to erase the entire database that was created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.046257Z",
     "iopub.status.busy": "2022-11-23T07:12:29.046083Z",
     "iopub.status.idle": "2022-11-23T07:12:29.047979Z",
     "shell.execute_reply": "2022-11-23T07:12:29.047699Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "d0.clear()\n",
    "print(d0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary can also be built using loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.049723Z",
     "iopub.status.busy": "2022-11-23T07:12:29.049500Z",
     "iopub.status.idle": "2022-11-23T07:12:29.051723Z",
     "shell.execute_reply": "2022-11-23T07:12:29.051445Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Mercury': 1, 'Venus': 2, 'Earth': 3, 'Mars': 4, 'Jupiter': 5, 'Saturn': 6, 'Uranus': 7, 'Neptune': 8}\n"
     ]
    }
   ],
   "source": [
    "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
    "for i in range(len(planets)):\n",
    "    d0[planets[i]] = i + 1\n",
    "print(d0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**values( )** function returns a list with all the assigned values in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.053431Z",
     "iopub.status.busy": "2022-11-23T07:12:29.053216Z",
     "iopub.status.idle": "2022-11-23T07:12:29.055485Z",
     "shell.execute_reply": "2022-11-23T07:12:29.055214Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d0.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**keys( )** function returns all the index or the keys to which contains the values that it was assigned to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.057200Z",
     "iopub.status.busy": "2022-11-23T07:12:29.056985Z",
     "iopub.status.idle": "2022-11-23T07:12:29.059228Z",
     "shell.execute_reply": "2022-11-23T07:12:29.058958Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d0.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**items( )** is returns a list containing both the list but each element in the dictionary is inside a tuple. This is same as the result that was obtained when zip function was used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.060982Z",
     "iopub.status.busy": "2022-11-23T07:12:29.060754Z",
     "iopub.status.idle": "2022-11-23T07:12:29.062975Z",
     "shell.execute_reply": "2022-11-23T07:12:29.062708Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Mercury', 1), ('Venus', 2), ('Earth', 3), ('Mars', 4), ('Jupiter', 5), ('Saturn', 6), ('Uranus', 7), ('Neptune', 8)])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d0.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** function is used to get the remove that particular element and this removed element can be assigned to a new variable. But remember only the value is stored and not the key. Because the is just a index value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-11-23T07:12:29.064673Z",
     "iopub.status.busy": "2022-11-23T07:12:29.064456Z",
     "iopub.status.idle": "2022-11-23T07:12:29.066522Z",
     "shell.execute_reply": "2022-11-23T07:12:29.066242Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Mercury': 1, 'Venus': 2, 'Mars': 4, 'Jupiter': 5, 'Saturn': 6, 'Uranus': 7, 'Neptune': 8}\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "d1 = d0.pop('Earth')\n",
    "print(d0)\n",
    "print(d1)"
   ]
  }
 ],
 "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}