DS_Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures or Derived data Types in Python:\n",
    "\n",
    "Storing multiple values of same or different types under a single name.\n",
    "They are collection of data.\n",
    "\n",
    "1. List\n",
    "2. Tuple\n",
    "3. String\n",
    "4. Dictionary\n",
    "5. Set  \n",
    "In this notebook, we'll discuss indepth on Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings:\n",
    "Strings are ordered collection or an array of characters.\n",
    "Represented by quotes either ' ' or \" \".  \n",
    "They are generally immutable. This means individual elements can't be changed.\n",
    "\n",
    "```python\n",
    "Example: 'Hello', \"Python\"\n",
    "```\n",
    "\n",
    "order of elements: index of element  \n",
    "Index - may be positive or negative  \n",
    "\n",
    "|Order (element) | First | Second | Third |...|Last|  \n",
    "|---|---|---|---|---|---|  \n",
    "|Positive Index| 0| 1| 2| ...| n-1|  \n",
    "|Negative Index| -n| -n+1| -n+2| ...| -1|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a String:\n",
    "\n",
    "1. '' or \"\"\n",
    "2. str()\n",
    "\n",
    "### 1. Quotes:\n",
    "```python\n",
    "str = 'String'\n",
    "```\n",
    "### 2. str()\n",
    "Syntax: \n",
    "```python\n",
    "str(value = None)\n",
    "```  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Hello'\n",
    "type(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = str([10, 20])\n",
    "print(s)\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Input:\n",
    "All the values that are taken using `input()` method as strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " String\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = input()\n",
    "type(s1)\n",
    "# Input: String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Strings:\n",
    "\n",
    "1. Concatenation\n",
    "2. Appending\n",
    "3. Multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Concatenation:\n",
    "Two strings can be concatenated by using `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'String Concatenation'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'String '\n",
    "str2 = 'Concatenation'\n",
    "str1+str2 # Concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Appending:\n",
    "A character can be appended to string using `+=` operator or by reassignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lets'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str3 = 'Let'\n",
    "ch = 's'\n",
    "str3 += ch # str3 = str3 + ch\n",
    "str3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. String Multiplication:\n",
    "String multiplication results a string with repitition. It can be done using `*` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Namaste Namaste Namaste Namaste '"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str4 = 'Namaste '\n",
    "str4*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in String Methods:\n",
    "There are various methods to work with strings. But Unlike lists, string methods don't change strings as ther are immutable. Hence the returned value should always be reassigned.\n",
    "\n",
    "Methods:\n",
    "1. capitalize\n",
    "2. upper\n",
    "3. lower\n",
    "4. Center\n",
    "5. swapcase\n",
    "6. find\n",
    "7. rfind\n",
    "8. index\n",
    "9. startswith\n",
    "10. endswith\n",
    "11. isalnum\n",
    "12. isalpha\n",
    "13. isdigit\n",
    "14. strip\n",
    "15. split\n",
    "16. join\n",
    "17. replace\n",
    "18. zfill\n",
    "19. enumerate\n",
    "20. len\n",
    "21. isupper\n",
    "22. islower\n",
    "23. lstrip\n",
    "24. rstrip\n",
    "25. partition\n",
    "26. ljust\n",
    "27. rjust\n",
    "28. sorted "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. capitalize:\n",
    "Capitalize the string. More specifically, first letter of the string in upper case and rest in lower case.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.capitalize()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hello'\n",
    "s1 = s1.capitalize()\n",
    "s1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. upper:\n",
    "Converts the string to upper case\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.upper()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hello'\n",
    "s1 = s1.upper()\n",
    "s1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. lower:\n",
    "Converts the string to lowercase\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.lower()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'HI'\n",
    "s1.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. center:\n",
    "Returns original string to center of given width. The empty places are filled using fillchar\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.center(width, fillchar)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*hii*'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hii'\n",
    "s1 = s1.center(5, '*')\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'---Well---'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = 'Well'\n",
    "s2 = s2.center(10, '-')\n",
    "s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. swapcase:\n",
    "Swaps the case of string to lower if in uppercase, to upper in lowercase\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.swapcase()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pYtHON'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'PyThon'\n",
    "s1.swapcase()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. find:\n",
    "Returns the index of start of substring if present in string else -1.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.find(substring, start = 0, end = length)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Python'\n",
    "s1.find('Py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. rfind:\n",
    "Returns index of start of last occurence substring if present in string else -1\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.rfind(substring, start = 0, end = length)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Hello Welcome'\n",
    "s1.rfind('el')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. index:\n",
    "Returns the index of substring given. Same as find but raises error if absent.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.index(substring, start = 0, end = length)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Python'\n",
    "s1.index('Py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. startswith:\n",
    "Checks if the given string starts with given Prefix.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.startswith(prefix, start = 0, end = length)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'preprocessing'\n",
    "str1.startswith('pre')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. endswith:\n",
    "Checks if the given string ends with the given suffix.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.endswith(suffix, start = 0, end = length)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'preprocessor'\n",
    "str1.endswith('or')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. isalnum:\n",
    "Checks if the given string is alpha-numeric, i.e., contains only alphabets or numbers.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.isalnum()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = '$hello_'\n",
    "s2.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3 = 'dev23'\n",
    "s3.isalnum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. isalpha:\n",
    "Checks if the given string is alphabetic, i.e., contains only alphabets.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.isalpha()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3 = 'dev23'\n",
    "s3.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4 = 'python'\n",
    "s4.isalpha()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. isdigit:\n",
    "Checks if the given string is numeric, i.e., contains only numbers.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.isdigit()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3 = 'dev23'\n",
    "s3.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s5 = '123'\n",
    "s5.isdigit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14. strip:\n",
    "Removes the leading and trailing whitespaces by default, if any. If *chars* is given (string only), it removes only the characters in it.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.strip(chars = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = ' Hello '\n",
    "str1.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'HhelloH '\n",
    "str2.strip('H ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15. split:\n",
    "Return a list of the words in the string, using `sep` as the delimiter. `maxsplit` gives the Maximum no. of splits to be done. The remaining string returned as last element. By default whitespaces, line feed and carriage returns are taken as delimiters.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.split(/, sep = None, maxsplit = -1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Hello\\n World\\r'\n",
    "str1.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World ']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'Hello-World '\n",
    "str2.split('-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World\\r']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Hello\\n World\\r'\n",
    "str1.split(maxsplit = 1) # Limiting no. of split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16. join:\n",
    "Returns a concatenated string of iterable (containing only strings) with *char* (string) as delimiter.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "char.join(iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HelloWorld'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['Hello', 'World']\n",
    "\"\".join(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['Hello', 'World']\n",
    "\" \".join(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello-World'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['Hello', 'World']\n",
    "\"-\".join(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 17. replace:\n",
    "Returns a copy of a string with given substring replaced by old substring. *count* is the max no. of occurences to be replaced, all be default.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.replace(old_string, new_string, count = -1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HeLLo WorLd'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Hello World'\n",
    "str1.replace('l','L')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18. zfill:\n",
    "Pads zeroes (0) to the start of the numeric string to fill the given width if width > length of string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.zfill(width)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = '123'\n",
    "num.zfill(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00123'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = '123'\n",
    "num.zfill(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 19. enumerate:\n",
    "Returns the enumeration object of given string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "enumerate(str)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Index, Value)\n",
      "(0, 'H')\n",
      "(1, 'e')\n",
      "(2, 'l')\n",
      "(3, 'l')\n",
      "(4, 'o')\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Hello'\n",
    "print('(Index, Value)')\n",
    "print(*enumerate(str1), sep='\\n') # enumeration object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 20. len:\n",
    "Returns the length o given string\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "len(str)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Prabhu'\n",
    "len(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 21. isupper:\n",
    "Checks if the given string is in uppercase.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.isupper()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'HYMN'\n",
    "str1.isupper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 22. islower:\n",
    "Checks if the given string is in lowercase.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.islower()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'welcome'\n",
    "str2.islower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 23. lstrip:\n",
    "Removes the leading whitespaces by default, if any. If *chars* is given (string only), it removes only the characters in it.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.lstrip(chars = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello '"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = ' Hello '\n",
    "str1.lstrip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 24. rstrip:\n",
    "Removes the trailing whitespaces by default, if any. If *chars* is given (string only), it removes only the characters in it.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.rstrip(chars = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Hello'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = ' Hello '\n",
    "str1.rstrip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 25. partition:\n",
    "Partition the string into three parts using the given separator. \n",
    "\n",
    "If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.\n",
    "\n",
    "If the separator is not found, returns a 3-tuple containing the original string and two empty strings.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.partition(sep)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hello', '-', 'World')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'Hello-World'\n",
    "str2.partition('-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hello-World', '', '')"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'Hello-World'\n",
    "str2.partition('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 26. ljust:\n",
    "Pads given char (default - space) to the end of the string to fill the given width if width > length of string. Left justified string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.ljust(width, fillchar = ' ')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hii**'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hii'\n",
    "s1.ljust(5, '*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 27. rjust:\n",
    "Pads given char (default - space) to the start of the string to fill the given width if width > length of string. Right justified string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.rjust(width, fillchar = ' ')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  hii'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hii'\n",
    "s1.rjust(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 28. sorted:\n",
    "Returns sorted string as a list based on given key.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "sorted(iterable, key = None, reverse = False)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['h', 'i', 'i']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'hii'\n",
    "sorted(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Elements in a string:\n",
    "\n",
    "Elements of a string can be accessed using index.\n",
    "\n",
    "*Example:*  \n",
    "Consider a string, \n",
    "```python\n",
    "s = 'Hello'\n",
    "```\n",
    "Length = 5\n",
    "\n",
    "| Element | 'H' | 'e' | 'l' | 'l' | 'o' |  \n",
    "|---|---|---|---|---|---|  \n",
    "|Position| 1| 2| 3| 4| 5|  \n",
    "|Positive Index| 0 | 1 | 2 | 3 | 4 |  \n",
    "|Negative Index| -5 | -4 | -3 | -2 | -1|  \n",
    "\n",
    "Calling $i^{th}$ element:   \n",
    "positive index: s [i-1]  \n",
    "negative index: s [i - 1 - length]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "s1 = 'Hello'\n",
    "print(s1[0])\n",
    "print(s1[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing operator:\n",
    "Used to get a substring of a string. Denoted by `[]`\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "string_name[start = 0 : stop = length : stride = 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n is Easy to Le'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Python is Easy to Learn'\n",
    "s1[5:-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing the elements in a string:\n",
    "1. Using loops\n",
    "2. Using * \n",
    "\n",
    "### 1. Looping:\n",
    "Use *for* or *while* loop to access element or string.\n",
    "\n",
    "### 2. Using * :\n",
    "Using `*` will convert the characters in the string into arguements of print method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome"
     ]
    }
   ],
   "source": [
    "s2 = 'Welcome'\n",
    "for i in s2:\n",
    "    print(i, end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Programming"
     ]
    }
   ],
   "source": [
    "s3 = 'Python Programming'\n",
    "for i in range(len(s3)):\n",
    "    print(s3[i], end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B o o k\n"
     ]
    }
   ],
   "source": [
    "s2 = 'Book'\n",
    "print(*s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with ASCII values:\n",
    "Two built in methods, *ord* and *chr* can be used to work with ASCII values.\n",
    "\n",
    "### 1. ord:\n",
    "Returns the decimal ASCII (ordinal) value or Unicode point of given one-character string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "ord(c)\n",
    "```\n",
    "\n",
    "### 2. chr:\n",
    "Returns the one character Unicode or ASCII string of given ordinal.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "chr(i)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'a'\n",
    "ord(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "o = 97\n",
    "chr(o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Comparison:\n",
    "Python allows usage of relational operators on strings.\n",
    "\n",
    "Python compares two strings using Lexicographical order (dictionary arrangement), i.e. using ASCII values of these characters.  \n",
    "This means that 'B'(ASCII value = 66) is smaller than 'b' (ASCII value = 98)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1 = 'Python'\n",
    "sample2 = 'midhun'\n",
    "sample1 > sample2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1 = 'PYTHON'\n",
    "sample2 = 'pYTHON'\n",
    "sample1 < sample2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1 = 'Hi'\n",
    "sample2 = 'Hello'\n",
    "sample1 > sample2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some other methods in Python Strings:\n",
    "1. max\n",
    "2. min\n",
    "3. reversed\n",
    "4. splitlines\n",
    "5. format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. max:\n",
    "Returns the maximum value in the given string. Returns the character with maximum ASCII value in the String by default.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "max(String, key = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'hello'\n",
    "max(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'l'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'hello'\n",
    "max(s, key = lambda x: s.count(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. min:\n",
    "Returns minimum value in the string. Returns the character with minimum ASCII value in the String by default.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "min(iterable, key = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'hello'\n",
    "min(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. reversed:\n",
    "Returns iterator object of reversed string.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "revrsed(sequence)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olleh"
     ]
    }
   ],
   "source": [
    "s = 'hello'\n",
    "for i in reversed(s):\n",
    "    print(i, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. splitlines:\n",
    "Returns a list of strings split with carriage return and line feed (CRLF) as separator.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.splitlines(keepends = False)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', '', 'Python']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Hello\\n\\rPython'\n",
    "s1.splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello\\n', '\\r', 'Python']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Hello\\n\\rPython'\n",
    "s1.splitlines(keepends = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. format:\n",
    "Returns formatted string as required.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str.format(*args, **kwargs)\n",
    "```\n",
    "\n",
    "It was already discussed at String formatting in [Introduction to Python Programming](Introduction_to_Python_Programming.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Formatting:\n",
    "Refer discussion in [Introduction to Python Programming](Introduction_to_Python_Programming.ipynb)"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}