Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# STRINGS:\n",
    "* A sequence of characters, enclosed either within a pair of single quotes or double quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assign String to a Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of s1 is <class 'str'>\n",
      "s1 =  str\n"
     ]
    }
   ],
   "source": [
    "#### Single line assignment\n",
    "s1 = 'str'\n",
    "print(\"Type of s1 is\",type(s1))\n",
    "print(\"s1 = \",s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of s2 is <class 'str'>\n",
      "s2 =  Multiline\n",
      "        string\n"
     ]
    }
   ],
   "source": [
    "#### Multiline assignment Using three single quotes\n",
    "s2 = '''Multiline\n",
    "        string'''\n",
    "print(\"Type of s2 is\",type(s2))\n",
    "print(\"s2 = \",s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of s3 is <class 'str'>\n",
      "s3 =  Multiline\n",
      "        string\n"
     ]
    }
   ],
   "source": [
    "#### Multiline assignment Using three double quotes\n",
    "s3 = \"\"\"Multiline\n",
    "        string\"\"\"\n",
    "print(\"Type of s3 is\",type(s3))\n",
    "print(\"s3 = \",s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ring'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Using Positive indexing\n",
    "s4 = 'String Slicing'\n",
    "#### Get the character from position 2 to 6(not included)\n",
    "s4[2:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ring'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Using Negitive indexing\n",
    "s5 = 'String Slicing'\n",
    "#### Using Negitive index Get the character from position 2 to 6(not included)\n",
    "s5[-12:-8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Srn lcn'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Printing even characters of the string\n",
    "s6 = 'String Slicing'\n",
    "s6[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tigSiig'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Printing odd characters of the string\n",
    "s6 = 'String Slicing'\n",
    "s6[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic operations\n",
    "* In python, only addition(+) and multiplication(*) two arithmetic operators are used in string operations.\n",
    "* Otherwise, Floor division (//), exponent(**), subtraction(-), division(/) and modulus(%) operators are not use with strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Arithmetic operations'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Adding two strings with space.\n",
    "s7 = 'Arithmetic'\n",
    "s8 = 'operations'\n",
    "#### Here '+' operator represents concatenation, not addition\n",
    "s7+' '+s8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MultiplyingMultiplyingMultiplying'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Multiplying two strings\n",
    "s9 = 'Multiplying'\n",
    "s9*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of methods in string Python = ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n"
     ]
    }
   ],
   "source": [
    "print(\"List of methods in string Python =\",dir(s9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### capitalize()\n",
    "&emsp;&emsp;&emsp;Converts the first character to upper case and remaining all characters to lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Capitalize\n"
     ]
    }
   ],
   "source": [
    "s10 = 'capITalizE'\n",
    "print(s10.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Capitalize'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Converts the first character to upper case and remaining all characters to lower case without using capitalize()\n",
    "def capitalize_dup(in1) :\n",
    "    s = ''\n",
    "    # Calculating ASCII values for zeroth index and convert to upper case\n",
    "    asc = ord(in1[0])\n",
    "    if(96<asc<123) :\n",
    "        s += chr(asc - 32) \n",
    "    # Converting all other cases to Lower case     \n",
    "    for i in in1[1:] :\n",
    "        asc = ord(i)\n",
    "        if(64<asc<91) :\n",
    "            s += chr(asc+32)\n",
    "        else :\n",
    "            s += i\n",
    "    return(s)\n",
    "\n",
    "capitalize_dup('capITalizE')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### casefold()\n",
    "&emsp;&emsp;&emsp;Converts enitre string into lower case\n",
    "<br>&emsp;&emsp;&emsp;It is used for caseless matching, i.e. ignores cases when comparing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'casefold'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s11 = 'CASEFOLD' \n",
    "s11.casefold()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "der fluss\n"
     ]
    }
   ],
   "source": [
    "#### the German lowercase letter 'ß' is equivalent to 'ss'.\n",
    "s11 = 'der Fluß'\n",
    "print(s11.casefold())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "223"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('ß')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### center()\n",
    "&emsp;&emsp;&emsp;Returns a centered string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  Center  '"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s12 = 'Center'\n",
    "s12.center(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### count()\n",
    "&emsp;&emsp;&emsp;Returns the number of times a specified value occurs in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s13 = 'aabbaaabaaaa'\n",
    "s13.count('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### encode()\n",
    "&emsp;&emsp;&emsp;Returns an encoded version of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pythön!\n",
      "b'pyth\\xc3\\xb6n!'\n",
      "b'pyth\\\\xf6n!'\n",
      "b'pythn!'\n",
      "b'pyth\\\\N{LATIN SMALL LETTER O WITH DIAERESIS}n!'\n",
      "b'pyth?n!'\n",
      "b'pyth&#246;n!'\n"
     ]
    }
   ],
   "source": [
    "s14 = 'pythön!'\n",
    "print(s14)\n",
    "# default encoding to utf-8\n",
    "s15 = s14.encode()\n",
    "print(s15)\n",
    "print(s14.encode(encoding=\"ascii\",errors=\"backslashreplace\"))\n",
    "print(s14.encode(encoding=\"ascii\",errors=\"ignore\"))\n",
    "print(s14.encode(encoding=\"ascii\",errors=\"namereplace\"))\n",
    "print(s14.encode(encoding=\"ascii\",errors=\"replace\"))\n",
    "print(s14.encode(encoding=\"ascii\",errors=\"xmlcharrefreplace\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### endswith()\n",
    "&emsp;&emsp;&emsp;Returns true if the string ends with the specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s16 = 'Endswith'\n",
    "print(s16.endswith('h'))\n",
    "print(s16.endswith('t'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### expandtabs()\n",
    "&emsp;&emsp;&emsp;Sets the tab size of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ex\tpa\tnd\t\n",
      "ex  pa  nd  \n",
      "ex          pa          nd          \n"
     ]
    }
   ],
   "source": [
    "s17 = 'ex\\tpa\\tnd\\t'\n",
    "print(s17)\n",
    "print(s17.expandtabs(2))\n",
    "print(s17.expandtabs(12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### find()\n",
    "&emsp;&emsp;&emsp;Searches the string for a specified value and returns the position of where it was found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "-1\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "s18 = 'find string'\n",
    "#### The find() method finds the first occurrence of the specified value.\n",
    "print(s18.find('i'))\n",
    "#### The find() method returns -1 if the value is not found\n",
    "print(s18.find('k'))\n",
    "#### search beetween specific positions\n",
    "print(s18.find('i', 5, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### format()\n",
    "&emsp;&emsp;&emsp;Formats specified values in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a, b, c\n",
      "a, b, c\n",
      "b, a, c\n",
      "c, b, a\n",
      "abracadabra\n"
     ]
    }
   ],
   "source": [
    "#### Accessing arguments by position:\n",
    "print('{0}, {1}, {2}'.format('a', 'b', 'c'))\n",
    "print('{}, {}, {}'.format('a', 'b', 'c'))\n",
    "print('{1}, {0}, {2}'.format('a', 'b', 'c'))\n",
    "print('{2}, {1}, {0}'.format(*'abc'))\n",
    "print('{0}{1}{0}'.format('abra', 'cad') )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10, 11\n",
      "10, 11\n"
     ]
    }
   ],
   "source": [
    "#### Accessing arguments by name:\n",
    "print('{a}, {b}'.format(a=10 ,b=11))\n",
    "dict1 = {'a':10, 'b':11}\n",
    "print('{a}, {b}'.format(**dict1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.\n"
     ]
    }
   ],
   "source": [
    "#### Accessing arguments’ attributes:\n",
    "c = 3-5j\n",
    "print('The complex number {0} is formed from the real part {0.real} and the imaginary part {0.imag}.'.format(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a, b, c, d\n"
     ]
    }
   ],
   "source": [
    "#### Accessing arguments’ items:\n",
    "list1 = ['a', 'b']\n",
    "list2 = ['c', 'd']\n",
    "print('{0[0]}, {0[1]}, {1[0]}, {1[1]}'.format(list1, list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "repr() shows quotes: 'test1'; str() doesn't: test2\n"
     ]
    }
   ],
   "source": [
    "#### Replacing %s and %r:\n",
    "print('repr() shows quotes: {!r}; str() doesn\\'t: {!s}'.format('test1', 'test2'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left aligned++++++++++++++++++\n",
      "-----------------right aligned\n",
      "***********centered***********\n"
     ]
    }
   ],
   "source": [
    "#### Aligning the text and specifying a width:\n",
    "print('{:+<30}'.format('left aligned'))\n",
    "print('{:->30}'.format('right aligned'))\n",
    "print('{:*^30}'.format('centered'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+3.140000, -3.140000\n",
      " 3.140000, -3.140000\n",
      "3.140000, -3.140000\n"
     ]
    }
   ],
   "source": [
    "#### Replacing %+f, %-f, and % f and specifying a sign:\n",
    "print('{:+f}, {:+f}'.format(3.14, -3.14))\n",
    "print('{: f}, {: f}'.format(3.14, -3.14))\n",
    "print('{:-f}, {:-f}'.format(3.14, -3.14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int: 42;  hex: 2a;  oct: 52;  bin: 101010\n",
      "int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010\n"
     ]
    }
   ],
   "source": [
    "#### Replacing %x and %o and converting the value to different bases:\n",
    "print(\"int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}\".format(42))\n",
    "print(\"int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}\".format(42))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,234,567,890\n"
     ]
    }
   ],
   "source": [
    "#### Using the comma as a thousands separator:\n",
    "print('{:,}'.format(1234567890))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentage: 98.89%\n"
     ]
    }
   ],
   "source": [
    "#### Expressing a percentage:\n",
    "print('Percentage: {:.2%}'.format(89/90))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-01-11 11:17:34\n"
     ]
    }
   ],
   "source": [
    "#### Using type-specific formatting:\n",
    "from datetime import datetime\n",
    "print('{:%Y-%m-%d %H:%M:%S}'.format(datetime.now()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left<<<<<<<<<<<<\n",
      "^^^^^center^^^^^\n",
      ">>>>>>>>>>>right\n"
     ]
    }
   ],
   "source": [
    "#### Nesting arguments\n",
    "for align, text in zip('<^>', ['left', 'center', 'right']):\n",
    "    print('{0:{fill}{align}16}'.format(text, fill=align, align=align))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### format_map()\n",
    "&emsp;&emsp;&emsp;Formats specified values in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4, -5\n"
     ]
    }
   ],
   "source": [
    "dict2 = {'x':4,'y':-5}\n",
    "print('{x}, {y}'.format_map(dict2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### index()\n",
    "&emsp;&emsp;&emsp;Searches the string for a specified value and returns the position of where it was found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "s19 = 'find string'\n",
    "#### The index() method finds the first occurrence of the specified value.\n",
    "print(s19.index('i'))\n",
    "#### search beetween specific positions\n",
    "print(s19.index('i', 5, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diff b/w index() and find()\n",
    "&emsp;&emsp;&emsp;If the value is not found, the find() method returns -1, but the index() method will raise an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-79f8e54fb6f4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ms20\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'find string'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms20\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfind\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'k'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms20\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'k'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "s20 = 'find string'\n",
    "print(s20.find('k'))\n",
    "print(s20.index('k'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isalnum()\n",
    "&emsp;&emsp;&emsp;Returns True if all characters in the string are alphanumeric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s21 = '98ka'\n",
    "print(s21.isalnum())\n",
    "s22 = '98ka-)'\n",
    "print(s22.isalnum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isalpha()\n",
    "&emsp;&emsp;&emsp;Returns True if all characters in the string are in the alphabet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s23 = 'string'\n",
    "print(s23.isalpha())\n",
    "s24 = 'string123'\n",
    "print(s24.isalpha())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isdecimal() vs isdigit() vs isnumeric()\n",
    "&emsp;&emsp;&emsp;**1. isdecimal()**: Returns True if all characters in the string are decimals\n",
    "<br>&emsp;&emsp;&emsp;**2. isdigit()**: Returns True if all characters in the string are digits\n",
    "<br>&emsp;&emsp;&emsp;**3. isnumeric()**: Returns True if all characters in the string are numeric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#### Is 42 a decimal or digit or numeric number\n",
    "print('42'.isdecimal())\n",
    "print('42'.isdigit())\n",
    "print('42'.isnumeric())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#### Is ² (Superscript Two) a decimal or digit or numeric number?\n",
    "print('²'.isdecimal())\n",
    "print('²'.isdigit())\n",
    "print('²'.isnumeric())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#### Is 0.3 a decimal or digit or numeric number?\n",
    "print('0.3'.isdecimal())\n",
    "print('0.3'.isdigit())\n",
    "print('0.3'.isnumeric())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isprintable()\n",
    "&emsp;&emsp;&emsp;Returns True if all characters in the string are printable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s24 = 'string'\n",
    "print(s24.isprintable())\n",
    "s25 = 'string\\n'\n",
    "print(s25.isprintable())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isspace()\n",
    "&emsp;&emsp;&emsp;Returns True if all characters in the string are whitespaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s26 = ' '\n",
    "print(s26.isspace())\n",
    "s27 = ' s'\n",
    "print(s27.isspace())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### istitle()\n",
    "&emsp;&emsp;&emsp;Returns True if the string follows the rules of a title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s28 = 'String Title'\n",
    "print(s28.istitle())\n",
    "s29 = 'String title'\n",
    "print(s29.istitle())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isupper()\n",
    "&emsp;&emsp;&emsp;Returns True all the characters in the string are uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s30 = 'STRING'\n",
    "print(s30.isupper())\n",
    "s31 = 'STRING\\n'\n",
    "print(s31.isupper())\n",
    "s32 = 'String'\n",
    "print(s32.isupper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### join()\n",
    "&emsp;&emsp;&emsp;Joins the elements of an iterable to the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a, b, c\n"
     ]
    }
   ],
   "source": [
    "list1 = ['a', 'b', 'c']\n",
    "print(', '.join(list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a$ b\n"
     ]
    }
   ],
   "source": [
    "#### Join all items in a dictionary into a string, using a the word \"$\" as separator\n",
    "dict1 = {'a':'a1', 'b':'b1'} # note that dicts are unordered\n",
    "print('$ '.join(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ljust()\n",
    "&emsp;&emsp;&emsp;Returns a left justified version of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string               left\n"
     ]
    }
   ],
   "source": [
    "s33 = 'string'\n",
    "s34 = 'left'\n",
    "print(s33.ljust(20),s34)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lower()\n",
    "&emsp;&emsp;&emsp;Converts a string into lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string\n"
     ]
    }
   ],
   "source": [
    "s35 = 'StriNg'\n",
    "print(s35.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lstrip()\n",
    "&emsp;&emsp;&emsp;Removes spaces on the left side of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string    \n"
     ]
    }
   ],
   "source": [
    "s36 = '   string    '\n",
    "print(s36.lstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string./,@\n"
     ]
    }
   ],
   "source": [
    "s37 = './,@string./,@'\n",
    "print(s37.lstrip('/.@,'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### maketrans()\n",
    "&emsp;&emsp;&emsp;Returns a translation table to be used in translations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{97: '123', 98: '456', 99: '789'}\n"
     ]
    }
   ],
   "source": [
    "#### Translation table using a dictionary with maketrans()\n",
    "dict = {\"a\": \"123\", \"b\": \"456\", \"c\": \"789\"}\n",
    "s38 = \"abc\"\n",
    "print(s38.maketrans(dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{97: 100, 98: 101, 99: 102}\n"
     ]
    }
   ],
   "source": [
    "#### Translation table using two strings with maketrans()\n",
    "# first string\n",
    "firstString = \"abc\"\n",
    "secondString = \"def\"\n",
    "string = \"abc\"\n",
    "print(string.maketrans(firstString, secondString))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### partition()\n",
    "&emsp;&emsp;&emsp;Returns a tuple where the string is parted into three parts\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;1 - everything before the \"match\"\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;2 - the \"match\"\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;3 - everything after the \"match\"\n",
    "<br>&emsp;&emsp;&emsp;If the specified value is not found, the partition() method returns a tuple containing: \n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;1 - the whole string\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;2 - an empty string\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;3 - an empty string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Before ', 'match', ' after')\n",
      "('Before match after', '', '')\n"
     ]
    }
   ],
   "source": [
    "s39 = 'Before match after'\n",
    "print(s39.partition('match'))\n",
    "print(s39.partition('string'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### replace()\n",
    "&emsp;&emsp;&emsp;Returns a string where a specified value is replaced with a specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ONE ONE ONE two two ONE\n",
      "ONE ONE one two two one\n"
     ]
    }
   ],
   "source": [
    "s40 = 'one one one two two one'\n",
    "print(s40.replace('one', 'ONE'))\n",
    "print(s40.replace('one', 'ONE', 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rfind()\n",
    "&emsp;&emsp;&emsp;Searches the string for a specified value and returns the last position of where it was found\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;The rfind() method finds the last occurrence of the specified value.\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;The rfind() method returns -1 if the value is not found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "s50 = 'aaabaaaba'\n",
    "print(s50.rfind('a'))\n",
    "print(s50.rfind('c'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rindex()\n",
    "&emsp;&emsp;&emsp;Searches the string for a specified value and returns the last position of where it was found\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;The rindex() method finds the last occurrence of the specified value.\n",
    "<br>&emsp;&emsp;&emsp;&emsp;&emsp;The rindex() method raises an exception if the value is not found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-57-ce10fa5cd193>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ms51\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'aaabaaaba'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms51\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms51\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'c'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "s51 = 'aaabaaaba'\n",
    "print(s51.rindex('a'))\n",
    "print(s51.rindex('c'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rjust()\n",
    "&emsp;&emsp;&emsp;&emsp;Returns a right justified version of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string                right\n"
     ]
    }
   ],
   "source": [
    "s52 = 'string'\n",
    "s53 = 'right'\n",
    "print(s52, s53.rjust(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rpartition()\n",
    "&emsp;&emsp;&emsp;Returns a tuple where the string is parted into three parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Before match after', 'match', ' after')\n"
     ]
    }
   ],
   "source": [
    "s54 ='Before match aftermatch after'\n",
    "print(s54.rpartition('match'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rsplit()\n",
    "&emsp;&emsp;&emsp;Splits the string at the specified separator, and returns a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', ' b', ' c']\n",
      "['a, b', ' c']\n"
     ]
    }
   ],
   "source": [
    "s55 = 'a, b, c'\n",
    "print(s55.rsplit(','))\n",
    "print(s55.rsplit(',', 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rstrip()\n",
    "&emsp;&emsp;&emsp;Returns a right trim version of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a\n"
     ]
    }
   ],
   "source": [
    "s56 = '   a   '\n",
    "print(s56.rstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./,@string\n"
     ]
    }
   ],
   "source": [
    "s57 = './,@string./,@'\n",
    "print(s57.rstrip('/.@,'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### split()\n",
    "&emsp;&emsp;&emsp;Splits the string at the specified separator, and returns a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', ' b', ' c']\n",
      "['a', ' b, c']\n"
     ]
    }
   ],
   "source": [
    "s58 = 'a, b, c'\n",
    "print(s58.split(','))\n",
    "print(s58.split(',', 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### splitlines()\n",
    "&emsp;&emsp;&emsp;Splits the string at line breaks and returns a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', ' b', ' c']\n",
      "['a\\n', ' b\\n', ' c']\n",
      "['a', ' b', ' c']\n"
     ]
    }
   ],
   "source": [
    "s59 = 'a\\n b\\n c'\n",
    "print(s59.splitlines())\n",
    "print(s59.splitlines(True))\n",
    "print(s59.splitlines(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### startswith()\n",
    "&emsp;&emsp;&emsp;Returns true if the string starts with the specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "s60 = 'string'\n",
    "print(s60.startswith('s'))\n",
    "print(s60.startswith('S'))\n",
    "print(s60.startswith('rin', 2, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### strip()\n",
    "&emsp;&emsp;&emsp; Returns Trimmed version of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "s61 = '   a   '\n",
    "print(s61.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### swapcase()\n",
    "&emsp;&emsp;&emsp; Swaps cases, lower case becomes upper case and vice versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sTrInG\n"
     ]
    }
   ],
   "source": [
    "s62 = 'StRiNg'\n",
    "print(s62.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### title()\n",
    "&emsp;&emsp;&emsp;Converts the first character of each word to upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sring Title\n"
     ]
    }
   ],
   "source": [
    "s63 = 'sring title'\n",
    "print(s63.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### translate()\n",
    "&emsp;&emsp;&emsp;Returns a translated string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ptring\n",
      "Ptring\n"
     ]
    }
   ],
   "source": [
    "#### use a dictionary with ascii codes to replace 83 (S) with 80 (P):\n",
    "mydict = {83:  80}\n",
    "s64 = 'String'\n",
    "print(s64.translate(mydict))\n",
    "\n",
    "#### Use a mapping table to replace \"S\" with \"P\":\n",
    "mytable = s64.maketrans(\"S\", \"P\");\n",
    "print(s64.translate(mytable));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### upper()\n",
    "&emsp;&emsp;&emsp;Converts a string into upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STRING\n"
     ]
    }
   ],
   "source": [
    "s65 = 'string'\n",
    "print(s65.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zfill()\n",
    "&emsp;&emsp;&emsp; Fills the string with a specified number of 0 values at the beginning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000string\n",
      "string fill\n",
      "0000007.00\n"
     ]
    }
   ],
   "source": [
    "s66 = \"string\"\n",
    "s67 = \"string fill\"\n",
    "s68 = \"7.00\"\n",
    "\n",
    "print(s66.zfill(10))\n",
    "print(s67.zfill(10))\n",
    "print(s68.zfill(10))"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}