002_Python_String.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Datatypes** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/02_Python_Datatypes)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Strings\n",
    "\n",
    "In this class you will learn to create, format, modify and delete strings in Python. Also, you will be introduced to various string operations and functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is String in Python?\n",
    "\n",
    "A string is a built-in type sequence of characters. It is used to handle **textual data** in python. Python **Strings are immutable sequences** of **Unicode** points. Creating Strings are simplest and easy to use in Python.\n",
    "\n",
    "A character is simply a symbol. For example, the English language has 26 characters.\n",
    "\n",
    "Computers do not deal with characters, they deal with numbers (binary). Even though you may see characters on your screen, internally it is stored and manipulated as a combination of 0s and 1s.\n",
    "\n",
    "This conversion of character to a number is called encoding, and the reverse process is decoding. ASCII and Unicode are some of the popular encodings used.\n",
    "\n",
    "In Python, a string is a sequence of Unicode characters. Unicode was introduced to include every character in all languages and bring uniformity in encoding. These Unicodes range from **$0_{hex}$** to **$10FFFF_{hex}$**. Normally, a Unicode is referred to by writing **\"U+\"** followed by its **hexadecimal** number. Thus strings in Python are a sequence of Unicode values. You can learn about Unicode from **[Python Unicode](https://docs.python.org/3.3/howto/unicode.html)**.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/s0.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to create a string in Python?\n",
    "\n",
    "Strings can be created by enclosing characters inside a **single quote** or **double-quotes**. Even **triple quotes** can be used in Python but generally used to represent multiline strings and docstrings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:46.494092Z",
     "start_time": "2021-10-02T09:53:46.468698Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello, welcome to\n",
      "           the world of Python\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "# defining strings in Python\n",
    "# all of the following are equivalent\n",
    "my_string = 'Hello'  # A string could be a single character or a bunch of texts\n",
    "print(my_string)\n",
    "\n",
    "my_string = \"Hello\"\n",
    "print(my_string)\n",
    "\n",
    "my_string = '''Hello'''\n",
    "print(my_string)\n",
    "\n",
    "# triple quotes string can extend multiple lines\n",
    "my_string = \"\"\"Hello, welcome to\n",
    "           the world of Python\"\"\"\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:46.616178Z",
     "start_time": "2021-10-02T09:53:46.496045Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a resarcher cum teacher and I enjoy teaching.\n",
      "I didn't find anything as rewarding as empowering people.\n",
      "That's why I created this repository.\n"
     ]
    }
   ],
   "source": [
    "# Multiline String\n",
    "\n",
    "multiline_string = '''I am a resarcher cum teacher and I enjoy teaching.\n",
    "I didn't find anything as rewarding as empowering people.\n",
    "That's why I created this repository.'''\n",
    "print(multiline_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:46.833005Z",
     "start_time": "2021-10-02T09:53:46.621061Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a resarcher cum teacher and I enjoy teaching.\n",
      "I didn't find anything as rewarding as empowering people.\n",
      "That's why I created this repository.\n"
     ]
    }
   ],
   "source": [
    "# Another way of doing the same thing\n",
    "\n",
    "multiline_string = \"\"\"I am a researcher cum teacher and I enjoy teaching.\n",
    "I didn't find anything as rewarding as empowering people.\n",
    "That's why I created this repository.\"\"\"\n",
    "print(multiline_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:47.017601Z",
     "start_time": "2021-10-02T09:53:46.843749Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Unpacking characters \n",
    "\n",
    "language = 'Python'\n",
    "a,b,c,d,e,f = language # unpacking sequence characters into variables\n",
    "print(a) # P\n",
    "print(b) # y\n",
    "print(c) # t \n",
    "print(d) # h\n",
    "print(e) # o\n",
    "print(f) # n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to access characters in a string?\n",
    "\n",
    "* In Python, Strings are stored as individual characters in a **contiguous memory location**. \n",
    "\n",
    "* The benefit of using String is that it can be accessed from both the **directions** (forward and backward).\n",
    "\n",
    "* Both forward as well as backward indexing are provided using Strings in Python.\n",
    "\n",
    "* Forward indexing starts with **`0,1,2,3,.... `**\n",
    "\n",
    "* Backward indexing starts with **`-1,-2,-3,-4,.... `**\n",
    "\n",
    "* Trying to access a character out of index range will raise an **`IndexError`**. The index must be an integer. We can't use floats or other types, this will result into **`IndexError`**.\n",
    "\n",
    "* Strings can be indexed with square brackets. Indexing starts from zero in Python.\n",
    "\n",
    "* We can access a range of items in a string by using the slicing operator **`:`**(colon).\n",
    "\n",
    "* And the **`len()`** function provides the length of a string\n",
    "\n",
    "```python\n",
    "str[0] = 'P' = str[-6] ,\n",
    "str[1] = 'Y' = str[-5] ,\n",
    "str[2] = 'T' = str[-4] ,\n",
    "str[3] = 'H' = str[-3] ,\n",
    "str[4] = 'O' = str[-2] , # refers to the second last item\n",
    "str[5] = 'N' = str[-1].  # refers to the last item\n",
    "```\n",
    "\n",
    "<div>\n",
    "<img src=\"img/s3.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:47.185588Z",
     "start_time": "2021-10-02T09:53:47.020531Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "language = 'Python'\n",
    "\n",
    "first_letter = language[0]\n",
    "print(first_letter) # P\n",
    "\n",
    "second_letter = language[1]\n",
    "print(second_letter) # y\n",
    "\n",
    "last_index = len(language) - 1\n",
    "last_letter = language[last_index]\n",
    "print(last_letter) # n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:47.400462Z",
     "start_time": "2021-10-02T09:53:47.189499Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "# If we want to start from right end we can use negative indexing. -1 is the last index\n",
    "\n",
    "language = 'Python'\n",
    "last_letter = language[-1]\n",
    "print(last_letter) # n\n",
    "second_last = language[-2]\n",
    "print(second_last) # o"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to access an index out of the range or use numbers other than an integer, we will get errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:53:48.121265Z",
     "start_time": "2021-10-02T09:53:47.404372Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str =  PYTHON\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-5485fcd6e515>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# index must be in range\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'str[15] = '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m15\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;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "# Accessing string characters in Python\n",
    "str = 'PYTHON'\n",
    "print('str = ', str)\n",
    "\n",
    "# index must be in range\n",
    "print('str[15] = ', str[15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:14.504257Z",
     "start_time": "2021-10-02T09:54:14.489607Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str =  PYTHON\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "string indices must be integers",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-2d37a15d2cb9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m# index must be an integer\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'str[1.50] = '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1.5\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;31mTypeError\u001b[0m: string indices must be integers"
     ]
    }
   ],
   "source": [
    "# Accessing string characters in Python\n",
    "\n",
    "str = 'PYTHON'\n",
    "print('str = ', str)\n",
    "\n",
    "# index must be an integer\n",
    "print('str[1.50] = ', str[1.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:15.272916Z",
     "start_time": "2021-10-02T09:54:15.262173Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pto\n"
     ]
    }
   ],
   "source": [
    "# Skipping character while splitting Python strings\n",
    "\n",
    "language = 'Python'\n",
    "pto = language[0:6:2] # \n",
    "print(pto) # pto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:16.060130Z",
     "start_time": "2021-10-02T09:54:16.039625Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M \t n\n",
      "i \t a\n",
      "l \t a\n",
      "a \t l\n",
      "a \t i\n",
      "n \t M\n"
     ]
    }
   ],
   "source": [
    "# Here, we are creating a simple program to retrieve String in reverse as well as normal form.\n",
    "\n",
    "name=\"Milaan\"\n",
    "length=len(name)\n",
    "i=0\n",
    "\n",
    "for n in range(-1,(-length-1),-1):\n",
    "    print(name[i],\"\\t\",name[n])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to slice a string in Python?\n",
    "\n",
    "Python String **slice** can be defined as a **substring** which is the part of the string. Therefore further substring can be obtained from a string.\n",
    "\n",
    "There can be many forms to slice a string, as string can be accessed or indexed from both the direction and hence string can also be sliced from both the directions.\n",
    "\n",
    "Slicing can be best visualized by considering the index to be between the elements as shown below.\n",
    "\n",
    "If we want to access a range, we need the index that will slice the portion from the string.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/s16.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "**Syntax** of Slice Operator :\n",
    "\n",
    "```python\n",
    "str[start : stop : step ]\n",
    "```\n",
    "\n",
    "other syntax of slice:\n",
    "\n",
    "```python\n",
    "str[start : stop]  # items start through stop-1\n",
    "\n",
    "str[start : ]      # items start through the rest of the array\n",
    "\n",
    "str[ : stop]       # items from the beginning through stop-1\n",
    "\n",
    "str[ : ]           # a copy of the whole array\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:17.289791Z",
     "start_time": "2021-10-02T09:54:17.270261Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string '123456789' string is 9 characters long\n",
      "First character of 123456789 is 1\n",
      "Last character of 123456789 is 9\n",
      "Last character of 123456789 is 9\n"
     ]
    }
   ],
   "source": [
    "s = '123456789' #Indexing strats from 0 to 8\n",
    "print(\"The string '%s' string is %d characters long\" %(s, len(s)) )\n",
    "print('First character of',s,'is',s[0])\n",
    "print('Last character of',s,'is',s[8])\n",
    "print('Last character of',s,'is',s[len(s)-1]) # [9-1] = [8] is 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices can be used to start counting from the back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:18.058451Z",
     "start_time": "2021-10-02T09:54:18.035014Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First character of 123456789 is 1\n",
      "First character of 123456789 is 1\n",
      "Second character of 123456789 is 2\n",
      "Last character of 123456789 is 9\n"
     ]
    }
   ],
   "source": [
    "print('First character of',s,'is',s[-len(s)])\n",
    "print('First character of',s,'is',s[(-9)])\n",
    "print('Second character of',s,'is',s[(-8)])\n",
    "print('Last character of',s,'is',s[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally a substring (range of characters) an be specified as using $a:b$ to specify the characters at index $a,a+1,\\ldots,b-1$. Note that the last charcter is *not* included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:18.903292Z",
     "start_time": "2021-10-02T09:54:18.888646Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First three characters 123\n",
      "Next three characters 456\n"
     ]
    }
   ],
   "source": [
    "print(\"First three characters\",s[0:3])\n",
    "print(\"Next three characters\",s[3:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An empty beginning and end of the range denotes the beginning/end of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:19.365269Z",
     "start_time": "2021-10-02T09:54:19.353554Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First three characters 123\n",
      "Last three characters 789\n"
     ]
    }
   ],
   "source": [
    "s = '123456789' #Indexing strats from 0 to 8\n",
    "print(\"First three characters\", s[:3])\n",
    "print(\"Last three characters\", s[-3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:19.841898Z",
     "start_time": "2021-10-02T09:54:19.825296Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str =  PYTHON\n",
      "str[0] =  P\n",
      "str[-1] =  N\n",
      "str[1:5] =  YTHO\n",
      "str[5:-2] =  HO\n"
     ]
    }
   ],
   "source": [
    "# Accessing string characters in Python\n",
    "\n",
    "str = 'PYTHON'\n",
    "print('str = ', str)\n",
    "\n",
    "#first character\n",
    "print('str[0] = ', str[0])\n",
    "\n",
    "#last character\n",
    "print('str[-1] = ', str[-1])\n",
    "\n",
    "#slicing 2nd to 5th character\n",
    "print('str[1:5] = ', str[1:5])\n",
    "\n",
    "#slicing 6th to 2nd last character\n",
    "print('str[5:-2] = ', str[3:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:20.282389Z",
     "start_time": "2021-10-02T09:54:20.181Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Example: \n",
    "\n",
    "s=\"Milan Python\"\n",
    "\n",
    "print(s[6:10])\n",
    "print(s[-12:-7])\n",
    "print(s[-1: :-1])  #reversed all string\n",
    "print(s[2: 10: 2]) #step = 2\n",
    "print(s[ : : -1])  #reversed all string\n",
    "print(s[ : 5])     #from 0 to 4\n",
    "print(s[3 : ])     #from 3 to end of the string\n",
    "print(s[ : ])      #copy all string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: Both the operands passed for concatenation must be of same type, else it will show an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Breaking appart strings\n",
    "\n",
    "When processing text, the ability to split strings appart is particularly useful. \n",
    "\n",
    "* `partition(separator)`: breaks a string into three parts based on a separator\n",
    "\n",
    "* `split()`: breaks string into words separated by white-space (optionally takes a separator as argument)\n",
    "\n",
    "* `join()`: joins the result of a split using string as separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:20.959236Z",
     "start_time": "2021-10-02T09:54:20.944590Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('one ', '➡', ' two ➡ three')\n",
      "['one', '➡', 'two', '➡', 'three']\n",
      "['one', 'two', 'three']\n",
      "one;two;three\n"
     ]
    }
   ],
   "source": [
    "s = \"one ➡ two ➡ three\"\n",
    "print( s.partition(\"➡\") )\n",
    "print( s.split() )\n",
    "print( s.split(\" ➡ \") )\n",
    "print( \";\".join( s.split(\" ➡ \") ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:21.296686Z",
     "start_time": "2021-10-02T09:54:21.268364Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This', 'will', 'split', 'all', 'words', 'into', 'a', 'list']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This will split all words into a list\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:21.420238Z",
     "start_time": "2021-10-02T09:54:21.400709Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This will join all words into a string'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' '.join(['This', 'will', 'join', 'all', 'words', 'into', 'a', 'string'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:21.728875Z",
     "start_time": "2021-10-02T09:54:21.714225Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Happy New Year'.find('ew')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:21.843638Z",
     "start_time": "2021-10-02T09:54:21.822Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'Happy New Year'.replace('Happy','Brilliant')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to change or delete a string?\n",
    "\n",
    "Strings are immutable. This means that elements of a string cannot be changed once they have been assigned. We can simply reassign different strings to the same name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:22.405727Z",
     "start_time": "2021-10-02T09:54:22.391075Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-9df797f83624>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'python'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmy_string\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'a'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_string = 'python'\n",
    "my_string[5] = 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:22.513162Z",
     "start_time": "2021-10-02T09:54:22.497536Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating new string 01X345 OK\n",
      "01X345 still OK\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-9e95083e441a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msX\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"still OK\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'X'\u001b[0m \u001b[1;31m# an error!!!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s='012345'\n",
    "sX=s[:2]+'X'+s[3:] # this creates a new string with 2 replaced by X\n",
    "print(\"creating new string\",sX,\"OK\")\n",
    "\n",
    "sX=s.replace('2','X') # the same thing\n",
    "print(sX,\"still OK\")\n",
    "\n",
    "s[2] = 'X' # an error!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We cannot delete or remove characters from a string. But deleting the string entirely is possible using the **`del`** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:22.942906Z",
     "start_time": "2021-10-02T09:54:22.922400Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-4a9f159cd120>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'python'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0mmy_string\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# deleting element of string generates error!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "my_string = 'python'\n",
    "del my_string[1]  # deleting element of string generates error!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:23.281820Z",
     "start_time": "2021-10-02T09:54:23.267173Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'my_string' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-a04242241123>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'python'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[1;31m# deleting whole string using 'del' keyword can delete it.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mmy_string\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'my_string' is not defined"
     ]
    }
   ],
   "source": [
    "my_string = 'python'\n",
    "del my_string # deleting whole string using 'del' keyword can delete it.\n",
    "my_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Strings Operations\n",
    "\n",
    "There are many operations that can be performed with strings which makes it one of the most used data types in Python.\n",
    "\n",
    "To learn more about the data types available in Python visit: **[Python Data Types](https://github.com/milaan9/01_Python_Introduction/blob/main/009_Python_Data_Types.ipynb)**.\n",
    "\n",
    "To perform operation on string, Python provides basically 3 types of Operators that are given below.\n",
    "\n",
    "* Basic Operators/Concatenation of Two or More Strings.\n",
    "* Membership Operators.\n",
    "* Relational Operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Basic Operators for concatenation of two or more strings\n",
    "\n",
    "There are two types of basic operators in String **`+`** and **`*`**.\n",
    "\n",
    "The **`+`** (concatenation) operator can be used to concatenates two or more string literals together.\n",
    "\n",
    "The **`*`** (Replication) operator can be used to repeat the string for a given number of times.\n",
    "\n",
    "#### String Concatenation Operator (**`+`**)\n",
    "Joining of two or more strings into a single one is called concatenation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:23.943530Z",
     "start_time": "2021-10-02T09:54:23.929372Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# String Concatenation\n",
    "\n",
    "a = \"Hello,\"\n",
    "b= 'World!'\n",
    "print(a+b)\n",
    "print(a+\" \"+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:24.036321Z",
     "start_time": "2021-10-02T09:54:24.029485Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# String Concatenation\n",
    "\n",
    "string1='World'\n",
    "string2='!'\n",
    "print('Hello,' + \" \" + string1 + string2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Expression | Output |\n",
    "|:----| :--- |\n",
    "| **`\"10\" + \"50\"`** |   **\"1050\"**  | \n",
    "| **`\"hello\" + \"009\"`** |   **\"hello009\"** | \n",
    "| **`\"hello99\" + \"world66\" `** |   **\"hello99world66\"** | \n",
    "\n",
    ">**Note:** Both the operands passed for concatenation must be of same type, else it will show an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:24.573991Z",
     "start_time": "2021-10-02T09:54:24.559342Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-26-4c669126467b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Example:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\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[1;34m\"HelloWorld\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m99\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "print(\"HelloWorld\"+99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python String Replication Operator (**`*`**)\n",
    "\n",
    "**Replication operator** uses two parameters for operation, One is the integer value and the other one is the String argument.\n",
    "\n",
    "The Replication operator is used to **repeat a string** number of times. The string will be repeated the number of times which is given by the **integer value**.\n",
    "\n",
    "| Expression | Output |\n",
    "|:----| :--- |\n",
    "| **`\"ArcX\" \\* 2`** |   **\"ArcXArcX\"**  | \n",
    "| **`3 *'5'`** |   **\"555\"** | \n",
    "| **`'@'* 5 `** |   **\"@@@@@\"** | \n",
    "\n",
    ">**Note:**: We can use Replication operator in any way i.e., int **`*`** string or string **`*`** **`int`**. Both the parameters passed cannot be of same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:24.909974Z",
     "start_time": "2021-10-02T09:54:24.884Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example:\n",
    "\n",
    "print(\"HelloWorld\" * 5)\n",
    "print(3 * \"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:25.158539Z",
     "start_time": "2021-10-02T09:54:25.145846Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World! Hello World! Hello World! Hello World! Hello World! \n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World! \"*5)  #note the space in between 'Hello' and 'World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:25.374879Z",
     "start_time": "2021-10-02T09:54:25.355349Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 + str2 =  HelloWorld!\n",
      "str1 * 3 = HelloHelloHello\n"
     ]
    }
   ],
   "source": [
    "# Python String Operations\n",
    "str1 = 'Hello'\n",
    "str2 ='World!'\n",
    "\n",
    "# using +\n",
    "print('str1 + str2 = ', str1 + str2)\n",
    "\n",
    "# using *\n",
    "print('str1 * 3 =', str1 * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to concatenate strings in different lines, we can use parentheses **`()`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:25.944292Z",
     "start_time": "2021-10-02T09:54:25.929647Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World!'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# two string literals together\n",
    "'Hello ''World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:26.050752Z",
     "start_time": "2021-10-02T09:54:26.027315Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using parentheses\n",
    "s = ('Hello '\n",
    "     'World')\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating Through a string\n",
    "\n",
    "We can iterate through a string using a **[for loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)**. Here is an example to count the number of  'l's in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:27.341944Z",
     "start_time": "2021-10-02T09:54:27.328275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 letters found\n"
     ]
    }
   ],
   "source": [
    "# Iterating through a string\n",
    "count = 0\n",
    "for letter in 'Hello World':\n",
    "    if(letter == 'l'):\n",
    "        count += 1\n",
    "print(count,'letters found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Python String Membership Operators\n",
    "\n",
    "Membership Operators are already discussed in the Operators section. Let see with context of String.\n",
    "\n",
    "There are two types of Membership operators :\n",
    "\n",
    "1. **`in`** - \"in\" operator returns true if a character or the entire substring is present in the specified string, otherwise false.\n",
    "\n",
    "2. **`not in`** - \"not in\" operator returns true if a character or entire substring does not exist in the specified string, otherwise false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:27.801479Z",
     "start_time": "2021-10-02T09:54:27.778043Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exmple of in operator ::\n",
      "True\n",
      "True\n",
      "False\n",
      "\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "str1=\"HelloWorld\"\n",
    "str2=\"Hello\"\n",
    "str3=\"World\"\n",
    "str4=\"Milan\"\n",
    "\n",
    "print('Exmple of in operator ::')\n",
    "print(str2 in str1)\n",
    "print(str3 in str1)\n",
    "print(str4 in str1)\n",
    "print()\n",
    "print(str2 not in str1)\n",
    "print(str3 not in str1)\n",
    "print(str4 not in str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:28.016844Z",
     "start_time": "2021-10-02T09:54:27.992429Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> 'a' in 'program'\n",
    "True\n",
    ">>> 'at' not in 'battle'\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Python Relational Operators \n",
    "\n",
    "All the comparison (relational) operators i.e., **(<, ><=, >=, ==, !=, <>)** are also applicable for strings. The Strings are compared based on the **ASCII value** or **Unicode**(i.e., dictionary Order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:28.535467Z",
     "start_time": "2021-10-02T09:54:28.521797Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "print(\"HelloWorld\"==\"HelloWorld\")\n",
    "print(\"helloWorld\">=\"HelloWorld\")\n",
    "print(\"H\"<\"h\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "The ASCII value of a is 97, b is 98, c is 99 and so on. The ASCII value of A is 65, B is 66, C is 67 and so on. The comparison between strings are done on the basis on ASCII value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`%`** operator is used to format a string inserting the value that comes after. It relies on the string containing a format specifier that identifies where to insert the value. The most common types of format specifiers are:\n",
    "\n",
    "   - **`%s`** ➡ string\n",
    "   - **`%d`** ➡ Integer\n",
    "   - **`%f`** ➡ Float\n",
    "   - **`%o`** ➡ Octal\n",
    "   - **`%x`** ➡ Hexadecimal\n",
    "   - **`%e`** ➡ exponential\n",
    "    \n",
    "These will be very familiar to anyone who has ever written a C or Java program and follow nearly exactly the same rules as the **[printf() function](https://en.wikipedia.org/wiki/Printf_format_string)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:29.168853Z",
     "start_time": "2021-10-02T09:54:29.151277Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Actual Number = 19\n",
      "Float of the number = 19.000000\n",
      "Octal equivalent of the number = 23\n",
      "Hexadecimal equivalent of the number = 13\n",
      "Exponential equivalent of the number = 1.900000e+01\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello %s\" % string1)\n",
    "print(\"Actual Number = %d\" %19)\n",
    "print(\"Float of the number = %f\" %19)\n",
    "print(\"Octal equivalent of the number = %o\" %19)\n",
    "print(\"Hexadecimal equivalent of the number = %x\" %19)\n",
    "print(\"Exponential equivalent of the number = %e\" %19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When referring to multiple variables parentheses is used. Values are inserted in the order they appear in the parantheses (more on tuples in the next section)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:29.626435Z",
     "start_time": "2021-10-02T09:54:29.609835Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World !. My name is Bond, you can call me 99\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello %s %s. My name is Bond, you can call me %d\" %(string1,string2,99))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify the width of the field and the number of decimal places to be used. \n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:30.050810Z",
     "start_time": "2021-10-02T09:54:30.029814Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Print width 10: |         x|\n",
      "Print width 10: |x         |\n",
      "The number pi = 3.1 to 1 decimal places\n",
      "The number pi = 3.14 to 2 decimal places\n",
      "More space pi =       3.14\n",
      "Pad pi with 0 = 0000003.14\n"
     ]
    }
   ],
   "source": [
    "print('Print width 10: |%10s|'%'x')\n",
    "print('Print width 10: |%-10s|'%'x') # left justified\n",
    "print(\"The number pi = %.1f to 1 decimal places\"%3.1415)\n",
    "print(\"The number pi = %.2f to 2 decimal places\"%3.1415)\n",
    "print(\"More space pi = %10.2f\"%3.1415)\n",
    "print(\"Pad pi with 0 = %010.2f\"%3.1415) # pad with zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in functions to Work with Python\n",
    "\n",
    "Various built-in functions that work with sequence work with strings as well.\n",
    "\n",
    "Some of the commonly used ones are **`enumerate()`** and **`len()`**. The **[enumerate()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/018_Python_enumerate%28%29.ipynb)** function returns an enumerate object. It contains the index and value of all the items in the string as pairs. This can be useful for iteration.\n",
    "\n",
    "Similarly, **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** returns the length (number of characters) of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:31.958296Z",
     "start_time": "2021-10-02T09:54:31.944628Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list(enumerate(str) =  [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]\n",
      "len(str) =  4\n"
     ]
    }
   ],
   "source": [
    "str = 'cold'\n",
    "\n",
    "# enumerate()\n",
    "list_enumerate = list(enumerate(str))\n",
    "print('list(enumerate(str) = ', list_enumerate)\n",
    "\n",
    "#character count\n",
    "print('len(str) = ', len(str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python String Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escape Sequence\n",
    "\n",
    "If we want to print a text like `He said, \"What's there?\"`, we can neither use single quotes nor double quotes. This will result in a SyntaxError as the text itself contains both single and double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:32.852463Z",
     "start_time": "2021-10-02T09:54:32.833909Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-39-5b2db8c64782>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-39-5b2db8c64782>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print(\"He said, \"What's there?\"\")\u001b[0m\n\u001b[1;37m                     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print(\"He said, \"What's there?\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to get around this problem is to use triple quotes. Alternatively, we can use escape sequences.\n",
    "\n",
    "An escape sequence starts with a backslash and is interpreted differently. If we use a single quote to represent a string, all the single quotes inside the string must be escaped. Similar is the case with double quotes. Here is how it can be done to represent the above text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:33.392579Z",
     "start_time": "2021-10-02T09:54:33.385742Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He said, \"What's there?\"\n",
      "He said, \"What's there?\"\n",
      "He said, \"What's there?\"\n"
     ]
    }
   ],
   "source": [
    "# using triple quotes\n",
    "print('''He said, \"What's there?\"''')\n",
    "\n",
    "# escaping single quotes\n",
    "print('He said, \"What\\'s there?\"')\n",
    "\n",
    "# escaping double quotes\n",
    "print(\"He said, \\\"What's there?\\\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here is a list of all the escape sequences supported by Python.\n",
    "\n",
    "| Escape Sequence | Description |\n",
    "|:----:| :--- |\n",
    "| **`\\newline`** |   Backslash and newline ignored  | \n",
    "| **`\\\\`** |   Backslash | \n",
    "| **`\\'`** |   Single quote | \n",
    "| **`\\\"`** |   Double quote | \n",
    "| **`\\a`** |   ASCII Bell | \n",
    "| **`\\b`** |   ASCII Backspace | \n",
    "| **`\\f`** |   ASCII Formfeed | \n",
    "| **`\\n`** |   ASCII Linefeed | \n",
    "| **`\\r`** |   ASCII Carriage Return |\n",
    "| **`\\t`** |   ASCII Horizontal Tab | \n",
    "| **`\\v`** |   ASCII Vertical Tab | \n",
    "| **`\\ooo`** |   Character with octal value ooo | \n",
    "| **`\\xHH`** |   Character with hexadecimal value HH | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:34.346808Z",
     "start_time": "2021-10-02T09:54:34.337044Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I hope every one enjoying the python tutorials.\n",
      "Do you ?\n",
      "Days\tChapters\tTopics\n",
      "Day 1\tChp 1\tPython Introduction\n",
      "Day 2\tChp 2\tPython Datatypes\n",
      "Day 3\tChp 3\tPython Flow Control\n",
      "Day 4\tChp 4\tPython Functions\n",
      "Day 5\tChp 5\tPython Files\n",
      "This is a back slash  symbol (\\)\n",
      "In every programming language it starts with \"Hello, World!\"\n"
     ]
    }
   ],
   "source": [
    "# Escape sequence\n",
    "\n",
    "print('I hope every one enjoying the python tutorials.\\nDo you ?') # '\\n' line break\n",
    "print('Days\\tChapters\\tTopics')  # '\\t' tab space\n",
    "print('Day 1\\tChp 1\\tPython Introduction')\n",
    "print('Day 2\\tChp 2\\tPython Datatypes')\n",
    "print('Day 3\\tChp 3\\tPython Flow Control')\n",
    "print('Day 4\\tChp 4\\tPython Functions')\n",
    "print('Day 5\\tChp 5\\tPython Files')\n",
    "print('This is a back slash  symbol (\\\\)') # To write a back slash\n",
    "print('In every programming language it starts with \\\"Hello, World!\\\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:34.777531Z",
     "start_time": "2021-10-02T09:54:34.757023Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Python32\\Lib\n",
      "This is printed\n",
      "in two lines\n",
      "This is HEX representation\n"
     ]
    }
   ],
   "source": [
    "# Here are some examples\n",
    "\n",
    "print(\"C:\\\\Python32\\\\Lib\")\n",
    "#C:\\Python32\\Lib\n",
    "\n",
    "print(\"This is printed\\nin two lines\")\n",
    "#This is printed\n",
    "#in two lines\n",
    "\n",
    "print(\"This is \\x48\\x45\\x58 representation\")\n",
    "#This is HEX representation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raw String to ignore escape sequence\n",
    "\n",
    "Sometimes we may wish to ignore the escape sequences inside a string. To do this we can place **`r`** or **`R`** in front of the string. This will imply that it is a raw string and any escape sequence inside it will be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:35.637999Z",
     "start_time": "2021-10-02T09:54:35.625306Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a \n",
      "good example\n"
     ]
    }
   ],
   "source": [
    "print(\"This is \\x61 \\ngood example\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:36.207411Z",
     "start_time": "2021-10-02T09:54:36.189835Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is \\x61 \\ngood example\n"
     ]
    }
   ],
   "source": [
    "print(r\"This is \\x61 \\ngood example\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `format()` Method for Formatting Strings\n",
    "\n",
    "The **`format()`** method that is available with the string object is very versatile and powerful in formatting strings. Format strings contain curly braces **`{}`** as placeholders or replacement fields which get replaced.\n",
    "\n",
    "We can use positional arguments or keyword arguments to specify the order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:37.316939Z",
     "start_time": "2021-10-02T09:54:37.306200Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Default Order ---\n",
      "Allan, Bill and Cory\n",
      "\n",
      "--- Positional Order ---\n",
      "Bill, Allan and Cory\n",
      "\n",
      "--- Keyword Order ---\n",
      "Cory, Bill and Allan\n"
     ]
    }
   ],
   "source": [
    "# Python string format() method\n",
    "\n",
    "# default(implicit) order\n",
    "default_order = \"{}, {} and {}\".format('Allan','Bill','Cory')\n",
    "print('\\n--- Default Order ---')\n",
    "print(default_order)\n",
    "\n",
    "# order using positional argument\n",
    "positional_order = \"{1}, {0} and {2}\".format('Allan','Bill','Cory')\n",
    "print('\\n--- Positional Order ---')\n",
    "print(positional_order)\n",
    "\n",
    "# order using keyword argument\n",
    "keyword_order = \"{s}, {b} and {j}\".format(j='Allan',b='Bill',s='Cory')\n",
    "print('\\n--- Keyword Order ---')\n",
    "print(keyword_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`format()`** method can have optional format specifications. They are separated from the field name using colon. For example, we can left-justify **`<`**, right-justify **`>`** or center **`^`** a string in the given space.\n",
    "\n",
    "We can also format integers as binary, hexadecimal, etc. and floats can be rounded or displayed in the exponent format. There are tons of formatting you can use. Visit here for all the **[string formatting available with the format()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/009_Python_String_format%28%29.ipynb)** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:38.229170Z",
     "start_time": "2021-10-02T09:54:38.209640Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Binary representation of 12 is 1100'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# formatting integers\n",
    "\"Binary representation of {0} is {0:b}\".format(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:38.677476Z",
     "start_time": "2021-10-02T09:54:38.656969Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Exponent representation: 1.966365e+03'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# formatting floats\n",
    "\"Exponent representation: {0:e}\".format(1966.365)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:39.076947Z",
     "start_time": "2021-10-02T09:54:39.057413Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One third is: 0.333'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# round off\n",
    "\"One third is: {0:.3f}\".format(1/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:39.431483Z",
     "start_time": "2021-10-02T09:54:39.414885Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'|bread     |  butter  |       jam|'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# string alignment\n",
    "\"|{:<10}|{:^10}|{:>10}|\".format('bread','butter','jam')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Old style formatting\n",
    "\n",
    "We can even format strings like the old **`sprintf()`** style used in C programming language. We use the **`%`** operator to accomplish this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:40.123964Z",
     "start_time": "2021-10-02T09:54:40.114198Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 36.35\n"
     ]
    }
   ],
   "source": [
    "x = 36.3456789\n",
    "print('The value of x is %3.2f' %x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:40.507801Z",
     "start_time": "2021-10-02T09:54:40.491203Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 36.3457\n"
     ]
    }
   ],
   "source": [
    "print('The value of x is %3.4f' %x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Python String Methods\n",
    "\n",
    "There are numerous methods available with the string object. The **`format()`** method that we mentioned above is one of them. \n",
    "\n",
    "Strings can be tranformed by a variety of functions that are all methods on a string. That is they are called by putting the function name with a **`.`** after the string. They include:\n",
    "\n",
    "* Upper vs lower case: **`upper()`**, **`lower()`**, **`captialize()`**, **`title()`** and **`swapcase()`**, **`join()`**, **`split()`**, **`find()`**, **`replace()`** etc, with mostly the obvious meaning. Note that `capitalize` makes the first letter of the string a capital only, while **`title`** selects upper case for the first letter of every word.\n",
    "\n",
    "\n",
    "* Padding strings: **`center(n)`**, **`ljust(n)`** and **`rjust(n)`** each place the string into a longer string of length n  padded by spaces (centered, left-justified or right-justified respectively). **`zfill(n)`** works similarly but pads with leading zeros.\n",
    "\n",
    "\n",
    "* Stripping strings: Often we want to remove spaces, this is achived with the functions **`strip()`**, **`lstrip()`**, and **`rstrip()`** respectively to remove from spaces from the both end, just left or just the right respectively. An optional argument can be used to list a set of other characters to be removed.\n",
    "\n",
    "Here is a complete list of all the **[built-in methods to work with Strings in Python](https://github.com/milaan9/02_Python_Datatypes/tree/main/002_Python_String_Methods)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:41.294533Z",
     "start_time": "2021-10-02T09:54:41.282814Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world! vs Hello World!\n",
      "upper case: 'HELLO WORLD!' lower case: 'hello world!' and swapped: 'HEllO WorlD!'\n",
      "|         Hello World          |\n",
      "|lots of space|\n",
      "%s without leading/trailing d,h,L or ! = |%s| eLLo wOR\n",
      "Hello Class\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "s=\"heLLo wORLd!\"\n",
    "print(s.capitalize(),\"vs\",s.title())\n",
    "\n",
    "print(\"upper case: '%s'\"%s.upper(),\"lower case: '%s'\"%s.lower(),\"and swapped: '%s'\"%s.swapcase())\n",
    "\n",
    "print('|%s|' % \"Hello World\".center(30)) # center in 30 characters\n",
    "\n",
    "print('|%s|'% \"     lots of space             \".strip()) # remove leading and trailing whitespace\n",
    "\n",
    "print('%s without leading/trailing d,h,L or ! = |%s|',s.strip(\"dhL!\"))\n",
    "\n",
    "print(\"Hello World\".replace(\"World\",\"Class\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:41.665189Z",
     "start_time": "2021-10-02T09:54:41.658355Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python datatypes\n"
     ]
    }
   ],
   "source": [
    "# capitalize(): Converts the first character the string to Capital Letter\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.capitalize()) # 'Python Datatypes'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:42.050983Z",
     "start_time": "2021-10-02T09:54:42.036334Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# count(): returns occurrences of substring in string, count(substring, start=.., end=..)\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.count('y')) # 2\n",
    "print(challenge.count('y', 6, 14)) # 1\n",
    "print(challenge.count('ty')) # 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:42.358641Z",
     "start_time": "2021-10-02T09:54:42.343993Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# endswith(): Checks if a string ends with a specified ending\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.endswith('es'))   # True\n",
    "print(challenge.endswith('type')) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:42.681931Z",
     "start_time": "2021-10-02T09:54:42.667280Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python  Datatypes\n",
      "Python    Datatypes\n"
     ]
    }
   ],
   "source": [
    "# expandtabs(): Replaces tab character with spaces, default tab size is 8. It takes tab size argument\n",
    "\n",
    "challenge = 'Python\\tDatatypes'\n",
    "print(challenge.expandtabs())   # 'Python  Datatypes'\n",
    "print(challenge.expandtabs(10)) # 'Python    Datatypes'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:42.958331Z",
     "start_time": "2021-10-02T09:54:42.943686Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# find(): Returns the index of first occurrence of substring\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.find('y'))  # 1\n",
    "print(challenge.find('u')) # -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:43.065772Z",
     "start_time": "2021-10-02T09:54:43.039399Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Milaan Parmar. I am a Lecturer. I live in Finland.\n"
     ]
    }
   ],
   "source": [
    "# format()\tformats string into nicer output    \n",
    "first_name = 'Milaan'\n",
    "last_name = 'Parmar'\n",
    "job = 'Lecturer'\n",
    "country = 'Finland'\n",
    "sentence = 'I am {} {}. I am a {}. I live in {}.'.format(first_name, last_name, job, country)\n",
    "print(sentence) # I am Milaan Parmar. I am a Lecturer. I live in Finland."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:43.388076Z",
     "start_time": "2021-10-02T09:54:43.373431Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# index(): Returns the index of substring\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.find('y'))  # 1\n",
    "print(challenge.find('th')) # 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:43.675715Z",
     "start_time": "2021-10-02T09:54:43.661069Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# isalnum(): Checks alphanumeric character\n",
    "\n",
    "challenge = 'PythonDatatypes'\n",
    "print(challenge.isalnum()) # True\n",
    "\n",
    "challenge = 'Pyth0nDatatypes'\n",
    "print(challenge.isalnum()) # True\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.isalnum()) # False\n",
    "\n",
    "challenge = 'Python Datatypes 2021'\n",
    "print(challenge.isalnum()) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:43.876429Z",
     "start_time": "2021-10-02T09:54:43.867639Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# isalpha(): Checks if all characters are alphabets\n",
    "\n",
    "challenge = 'PythonDatatypes'\n",
    "print(challenge.isalpha()) # True\n",
    "\n",
    "num = '123'\n",
    "print(num.isalpha())      # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:44.367702Z",
     "start_time": "2021-10-02T09:54:44.353055Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# isdecimal(): Checks Decimal Characters\n",
    "\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.find('y'))  # 1\n",
    "print(challenge.find('th')) # 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:44.597228Z",
     "start_time": "2021-10-02T09:54:44.577696Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# isdigit(): Checks Digit Characters\n",
    "\n",
    "challenge = 'Ninety'\n",
    "print(challenge.isdigit()) # False\n",
    "challenge = '90'\n",
    "print(challenge.isdigit())   # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:44.904399Z",
     "start_time": "2021-10-02T09:54:44.895612Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# isdecimal():Checks decimal characters\n",
    "\n",
    "num = '30'\n",
    "print(num.isdecimal()) # True\n",
    "num = '30.6'\n",
    "print(num.isdecimal()) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:45.122200Z",
     "start_time": "2021-10-02T09:54:45.101693Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# isidentifier():Checks for valid identifier means it check if a string is a valid variable name\n",
    "\n",
    "challenge = '2021PythonDatatypes'\n",
    "print(challenge.isidentifier()) # False, because it starts with a number\n",
    "challenge = 'Python_Datatypes'\n",
    "print(challenge.isidentifier()) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:45.612994Z",
     "start_time": "2021-10-02T09:54:45.606157Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# islower():Checks if all alphabets in a string are lowercase\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.islower()) # True\n",
    "challenge = 'Python datatypes'\n",
    "print(challenge.islower()) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:45.998787Z",
     "start_time": "2021-10-02T09:54:45.984139Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# isupper(): returns if all characters are uppercase characters\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.isupper()) #  False\n",
    "challenge = 'PYTHON DATATYPES'\n",
    "print(challenge.isupper()) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:46.582851Z",
     "start_time": "2021-10-02T09:54:46.575041Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# isnumeric():Checks numeric characters\n",
    "\n",
    "num = '90'\n",
    "print(num.isnumeric())         # True\n",
    "print('ninety'.isnumeric())    # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:46.923717Z",
     "start_time": "2021-10-02T09:54:46.909068Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HTML#, CSS#, JavaScript#, React\n"
     ]
    }
   ],
   "source": [
    "# join(): Returns a concatenated string\n",
    "\n",
    "web_tech = ['HTML', 'CSS', 'JavaScript', 'React']\n",
    "result = '#, '.join(web_tech)\n",
    "print(result) # 'HTML# CSS# JavaScript# React'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:47.339298Z",
     "start_time": "2021-10-02T09:54:47.325629Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " python datatypes \n"
     ]
    }
   ],
   "source": [
    "# strip(): Removes both leading and trailing characters\n",
    "\n",
    "challenge = ' python datatypes '\n",
    "print(challenge.strip('y')) # 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:47.706536Z",
     "start_time": "2021-10-02T09:54:47.692864Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python data-types\n"
     ]
    }
   ],
   "source": [
    "# replace(): Replaces substring inside\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.replace('datatypes', 'data-types')) # 'thirty days of coding'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:48.015660Z",
     "start_time": "2021-10-02T09:54:47.999062Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python', 'datatypes']\n"
     ]
    }
   ],
   "source": [
    "# split():Splits String from Left\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.split()) # ['python', 'datatypes']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:48.385339Z",
     "start_time": "2021-10-02T09:54:48.371668Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Datatypes\n"
     ]
    }
   ],
   "source": [
    "# title(): Returns a Title Cased String\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.title()) # Python Datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:48.739886Z",
     "start_time": "2021-10-02T09:54:48.726213Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PYTHON DATATYPES\n",
      "pYTHON dATATYPES\n"
     ]
    }
   ],
   "source": [
    "# swapcase(): Checks if String Starts with the Specified String\n",
    "  \n",
    "challenge = 'python datatypes'\n",
    "print(challenge.swapcase())   # PYTHON DATATYPES\n",
    "challenge = 'Python Datatypes'\n",
    "print(challenge.swapcase())  # pYTHON dATATYPES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:49.063167Z",
     "start_time": "2021-10-02T09:54:49.051449Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# startswith(): Checks if String Starts with the Specified String\n",
    "\n",
    "challenge = 'python datatypes'\n",
    "print(challenge.startswith('python')) # True\n",
    "challenge = '2 python datatypes'\n",
    "print(challenge.startswith('two')) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inspecting Strings\n",
    "\n",
    "There are also lost of ways to inspect or check strings. Examples of a few of these are given here:\n",
    "\n",
    "* Checking the start or end of a string: **`startswith(\"string\")`** and **`endswith(\"string\")`** checks if it starts/ends with the string given as argument\n",
    "\n",
    "* Capitalisation: There are boolean counterparts for all forms of capitalisation, such as **`isupper()`**, **`islower()`** and **`istitle()`**\n",
    "\n",
    "* Character type: does the string only contain the characters:\n",
    "  * 0-9: **`isdecimal()`**. Note there is also **`isnumeric()`** and **`isdigit()`** which are effectively the same function except for certain unicode characters\n",
    "  * a-zA-Z: **`isalpha()`** or combined with digits: **`isalnum()`**\n",
    "  * non-control code: **`isprintable()`** accepts anything except '\\n' an other ASCII control codes\n",
    "  * \\t\\n \\r (white space characters): **`isspace()`**\n",
    "  * Suitable as variable name: **`isidentifier()`**\n",
    "  \n",
    "* Find elements of string: **`s.count(w)`** finds the number of times **`w`** occurs in **`s`**, while **`s.find(w)`** and **`s.rfind(w)`** find the first and last position of the string **`w`** in **`s`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T09:54:50.266457Z",
     "start_time": "2021-10-02T09:54:50.251809Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of 'Hello World' is 11 characters\n",
      "There are 3 'l's but only 1 World in Hello World\n",
      "\"el\" is at index 1 in Hello World\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "s=\"Hello World\"\n",
    "print(\"The length of '%s' is\"%s,len(s),\"characters\") # len() gives length of the string\n",
    "\n",
    "s.startswith(\"Hello\") and s.endswith(\"World\") # check start/end\n",
    "\n",
    "# count strings\n",
    "print(\"There are %d 'l's but only %d World in %s\" % (s.count('l'),s.count('World'),s))\n",
    "\n",
    "print('\"el\" is at index',s.find('el'),\"in\",s) #index from 0 or -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>String</span>\n",
    "\n",
    "1. Concatenate the string **`Python`**, **`4`**, **`Data`**, **`Science`** to a single string, **`Python 4 Data Science`**.\n",
    "\n",
    "2. Declare a variable named **`course`** and assign it to an initial value **`Python 4 Data Science`**.\n",
    "\n",
    "3. Print the length of the **`course`** string using **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** method and **[print()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/051_Python_print%28%29.ipynb)**.\n",
    "\n",
    "4. Change all the characters of variable company to uppercase and lowercase letters using **[upper()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/026_Python_String_upper%28%29.ipynb)** and **[lower()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/025_Python_String_lower%28%29.ipynb)** method.\n",
    "\n",
    "5. Use **[capitalize()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/001_Python_String_capitalize%28%29.ipynb)**, **[title()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/042_Python_String_title%28%29.ipynb)**, **[swapcase()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/027_Python_String_swapcase%28%29.ipynb)** methods to format the value of the string **`Python 4 Data Science`**.\n",
    "\n",
    "6. Cut(slice) out the first word of **`Python 4 Data Science`**.\n",
    "\n",
    "7. Check if **`Python 4 Data Science`** string contains a word **`Python`** using the method: **[index()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/010_Python_String_index%28%29.ipynb)**, **[find()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/008_Python_String_find%28%29.ipynb)** or other methods.\n",
    "\n",
    "8. Change **`Python 4 Data Science`** to **`Python 4 Everybody`** using the **[replace()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/035_Python_String_replace%28%29.ipynb)** method or other methods.\n",
    "\n",
    "9. Split the string **`Python 4 Data Science`** using space as the separator (**[split()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/038_Python_String_split%28%29.ipynb)**).\n",
    "\n",
    "11. **`Google, Facebook, Microsoft, Apple, IBM, Oracle, Amazon`** split the string at the comma.\n",
    "\n",
    "12. What is the character at index 9 in the string **`Python 4 Data Science`**.\n",
    "\n",
    "13. What is the second last index of the string **`Python 4 Data Science`**.\n",
    "\n",
    "14. Create an acronym or an abbreviation for the name **`Python 4 Data Science`**.\n",
    "\n",
    "15. Use **[index()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/010_Python_String_index%28%29.ipynb)** to determine the position of the first occurrence of **`D`** in **`Python 4 Data Science`**.\n",
    "\n",
    "16. Use **[rfind](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/036_Python_String_rfind%28%29.ipynb)** to determine the position of the last occurrence of **`e`** in **`Python 4 Data Science`**.\n",
    "\n",
    "17. Use **[index()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/010_Python_String_index%28%29.ipynb)** or **[find()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/008_Python_String_find%28%29.ipynb)** to find the position of the first occurrence of the word **`because`** in the following sentence: \n",
    "\n",
    "    - **`We cannot end the sentence with ‘because’, because ‘because’ is a conjunction.`**.\n",
    "\n",
    "18. Use **[rindex](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/037_Python_String_rindex%28%29.ipynb)** to find the position of the first and last occurrence of the word **`because`** in the following sentence: \n",
    "\n",
    "    - **`We cannot end the sentence with ‘because’, because ‘because’ is a conjunction.`**.\n",
    "\n",
    "19. Slice out the phrase **`‘because’, because ‘because’`** in the following sentence: \n",
    "\n",
    "    - **`We cannot end the sentence with ‘because’, because ‘because’ is a conjunction.`**.\n",
    "\n",
    "20. Does **`Python 4 Data Science`** start with a substring **`Python`**?\n",
    "\n",
    "21. Does '**`Python 4 Data Science`** contains with a substring **`Python`**?\n",
    "\n",
    "22. **`             Python 4 DataScience                                  `** remove the left and right trailing spaces in the given string.\n",
    "\n",
    "23. The following list contains the names of some of python libraries: **`['Django', 'Flask', 'Bottle', 'Pyramid', 'Falcon']`**. Join the list with a hash with space string.\n",
    "\n",
    "24. Which one of the following variables return True when we use the method **[isidentifier()](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String_Methods/015_Python_String_isidentifier%28%29.ipynb)**\n",
    "    - ```py\n",
    "    2021PythonDataypes\n",
    "    Python_Dataypes_2021\n",
    "    ```\n",
    "25. Make the following using string formatting methods:\n",
    "\n",
    "    - ```py\n",
    "8 + 6 = 14\n",
    "8 - 6 = 2\n",
    "8 * 6 = 48\n",
    "8 / 6 = 1.33\n",
    "8 % 6 = 2\n",
    "8 // 6 = 1\n",
    "8 ** 6 = 262144\n",
    "    ```\n",
    "\n",
    "26. Use a **new line** and **tab** escape sequence to print the following lines.\n",
    "    - ```py\n",
    "    Name      Age     Country   City\n",
    "    Milaan    96      Finland   Tampere\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced string processing\n",
    "For more advanced string processing there are many libraries available in Python including for example:\n",
    "* **re** for regular expression based searching and splitting of strings\n",
    "* **html** for manipulating HTML format text\n",
    "* **textwrap** for reformatting ASCII text\n",
    "* ... and many more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}