2_strings_and_lists/02_strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit - 2\n",
    "## Strings\n",
    "\n",
    "**Content**:\n",
    "- String representation  \n",
    "- Indexing  \n",
    "- Slicing  \n",
    "- String Operations  \n",
    "- Formatting Strings  \n",
    "- Other string operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String and String Representation\n",
    "\n",
    "Definition:  \n",
    "\n",
    "    A Python String is the collection of the characters surrounded by single-quotes(''), double-quotes or triple-quotes.  \n",
    "    Strings are collections of unicode characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adani Uni\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "example = \"Adani Uni\"\n",
    "\n",
    "print(example)\n",
    "print(type(example))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Indexing\n",
    "\n",
    "Definition:  \n",
    "\n",
    "    Indexing means refering to an element by its location or position or an index number.\n",
    "\n",
    "The User-Defined String can be represented as:\n",
    "\n",
    "    |-9|-8|-7|-6|-5|-4|-3|-2|-1| - Negative Indexing\n",
    "    |A |d |a |n |i |  |U |n |i | - String as a sequence of blocks\n",
    "    |0 |1 |2 |3 |4 |5 |6 |7 |8 | - Positive Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character at Index 2: a\n"
     ]
    }
   ],
   "source": [
    "print(f\"Character at Index 2: {example[2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Slicing\n",
    "\n",
    "Definition:  \n",
    "\n",
    "    To access a range of characters in the string.\n",
    "\n",
    "Syntax:  \n",
    "\n",
    "    string_name[start : end : step]  \n",
    "    where, string_name -> Variable name  \n",
    "           start -> Starting index for the slicing (Included) - Leave Empty if you want to start from beginning of the string.  \n",
    "           end -> Ending index for the slicing (Excluded) - Leave Empty if you want to end at the end of the string.  \n",
    "           step -> Specified the no. of characters to jump while performing the slicing (By default - 1). It is not required.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive Indexing:\n",
      "example[1:5]: dani\n",
      "example[6:9]: Uni\n",
      "example[:3]: Ada\n",
      "\n",
      "Negative Indexing:\n",
      "example[-4:-8]: dani\n",
      "example[-3:]: Uni\n",
      "\n",
      "Indexing with Step:\n",
      "example[::2]: AaiUi\n",
      "example[::-2]: iUiaA\n",
      "example[1:5:2]: dn\n"
     ]
    }
   ],
   "source": [
    "# Positive Indexing\n",
    "print(\"Positive Indexing:\")\n",
    "print(f\"example[1:5]: {example[1:5]}\")\n",
    "print(f\"example[6:9]: {example[6:9]}\")\n",
    "print(f\"example[:3]: {example[:3]}\")\n",
    "\n",
    "# Negative Indexing\n",
    "print(\"\\nNegative Indexing:\")\n",
    "print(f\"example[-4:-8]: {example[-8:-4]}\")\n",
    "print(f\"example[-3:]: {example[-3:]}\")\n",
    "\n",
    "# Step\n",
    "print(\"\\nIndexing with Step:\")\n",
    "print(f\"example[::2]: {example[::2]}\")\n",
    "print(f\"example[::-2]: {example[::-2]}\")\n",
    "print(f\"example[1:5:2]: {example[1:5:2]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example[::-1]: inU inadA\n"
     ]
    }
   ],
   "source": [
    "# Reverse a String with Slicing\n",
    "print(f\"example[::-1]: {example[::-1]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Extract First Name with both +ve and -ve Indexing -\n",
      "With +ve Indexing: Madhur\n",
      "With -ve Indexing: Madhur\n",
      "\n",
      "Extract full name -\n",
      "Full Name: Madhur Prajapati\n",
      "\n",
      "Reverse the String -\n",
      "Reverse: itapajarP ruhdaM si eman yM\n"
     ]
    }
   ],
   "source": [
    "# A String\n",
    "name = \"My name is Madhur Prajapati\"\n",
    "\n",
    "# Extract First Name with both +ve and -ve Indexing\n",
    "print(\"\\nExtract First Name with both +ve and -ve Indexing -\")\n",
    "print(f\"With +ve Indexing: {name[11:17]}\")\n",
    "print(f\"With -ve Indexing: {name[-16:-10]}\")\n",
    "\n",
    "# Extract full name\n",
    "print(\"\\nExtract full name -\")\n",
    "print(f\"Full Name: {name[11:]}\")\n",
    "\n",
    "# Reverse the String\n",
    "print(\"\\nReverse the String -\")\n",
    "print(f\"Reverse: {name[::-1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods\n",
    "\n",
    "upper() - To change the string to Upper-Case  \n",
    "lower() - To change the string to Lower-Case  \n",
    "strip() - To remove whitespaces from the start and end of the string  \n",
    "lstrip() - To remove whitespaces from the start of the string only  \n",
    "rstrip() - To remove whitespaces from the end of the string only  \n",
    "replace() - To replace a specific character in the string  \n",
    "title() - To make the first character of every word in string capital (Title-Case)\n",
    "capitalize() - To make the first letter of string capital  \n",
    "count() - To count the occurences of a particular character(s) in the string  \n",
    "find() - To find the (first occurence) starting index of the character(s)  \n",
    "index() - To find the index of a particular letter or character  \n",
    "max() - To find the character with the highest ASCII value in the string  \n",
    "min() - To find the character with the lowest ASCII value in the string  \n",
    "len() - To get the length of the String  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upper-Case: EXAMPLE STRING\n",
      "Lower-Case: example string\n",
      "Strip: Example Two\n",
      "L-Strip: Example Two     \n",
      "R-Strip:      Example Two\n",
      "Replacing H in example_three: Jello\n",
      "Title: All Small Example\n",
      "Capitalize: All small example\n",
      "Count ('python'): 2\n",
      "Find ('love'): 2\n",
      "Index ('love'): 2\n",
      "Max: y\n",
      "Min:  \n",
      "Length of example: 14\n"
     ]
    }
   ],
   "source": [
    "# String Operations\n",
    "\n",
    "# Strings\n",
    "example = 'Example String'\n",
    "example_two = \"     Example Two     \"\n",
    "example_three = \"Hello\"\n",
    "example_four = 'all small example'\n",
    "example_five = \"I love python, python is a simple language\"\n",
    "\n",
    "# String Methods/Operations\n",
    "print(f\"Upper-Case: {example.upper()}\")\n",
    "print(f\"Lower-Case: {example.lower()}\")\n",
    "print(f\"Strip: {example_two.strip()}\")\n",
    "print(f\"L-Strip: {example_two.lstrip()}\")\n",
    "print(f\"R-Strip: {example_two.rstrip()}\")\n",
    "print(f\"Replacing H in example_three: {example_three.replace('H', 'J')}\")\n",
    "print(f\"Title: {example_four.title()}\")\n",
    "print(f\"Capitalize: {example_four.capitalize()}\")\n",
    "print(f\"Count ('python'): {example_five.count('python')}\")\n",
    "print(f\"Find ('love'): {example_five.find('love')}\")\n",
    "print(f\"Index ('love'): {example_five.index('love')}\")\n",
    "print(f\"Max: {max(example_five)}\")\n",
    "print(f\"Min: {min(example_five)}\")\n",
    "print(f\"Length of example: {len(example)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Concatenation\n",
    "\n",
    "Definition: It is the technique of combining two strings.  \n",
    "\n",
    "There are multiple ways to implement string concatenation:\n",
    "\n",
    "    1. Using '+' operator\n",
    "    2. Using join() function\n",
    "    3. Using ','\n",
    "    4. Using '%'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method - 1: HelloWorld\n",
      "Method - 1: Hello World\n",
      "Method - 2: Hello World\n",
      "Method - 3:  Hello World\n",
      "Method - 4: Hello World\n"
     ]
    }
   ],
   "source": [
    "# String Concatenation\n",
    "\n",
    "# Strings\n",
    "string_one = \"Hello\"\n",
    "string_two = \"World\"\n",
    "\n",
    "# Method - 1 (Using '+' operator):\n",
    "print(f\"Method - 1: {string_one + string_two}\")\n",
    "print(f\"Method - 1: {string_one + ' ' +string_two}\")\n",
    "\n",
    "# Method - 2 (Using 'join'):\n",
    "print(f\"Method - 2: {' '.join([string_one, string_two])}\")\n",
    "\n",
    "# Method - 3 (Using ',')\n",
    "print(\"Method - 3: \", string_one, string_two)\n",
    "\n",
    "# Method - 4(Using '%')\n",
    "print(\"Method - 4: %s %s\" %(string_one, string_two))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operations\n",
    "\n",
    "We can perform multiple operations on string, like:\n",
    "\n",
    "    1. Addition/Concatenation\n",
    "    2. Multiplication\n",
    "    3. Append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition operation (Add two strings): HelloWorld\n",
      "Multiplication operation (Print the string 5 times): HelloHelloHelloHelloHello\n",
      "Append: HelloWorld\n"
     ]
    }
   ],
   "source": [
    "# String Operations\n",
    "\n",
    "# Strings\n",
    "string_one = \"Hello\"\n",
    "string_two = \"World\"\n",
    "\n",
    "# Operations\n",
    "print(f\"Addition operation (Add two strings): {string_one + string_two}\")\n",
    "print(f\"Multiplication operation (Print the string 5 times): {5 * string_one}\")\n",
    "print(f\"Append: {string_one + string_two}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formatting\n",
    "\n",
    "Definition of 'format' function:\n",
    "- We can combine strings and number using format function\n",
    "- The format function/method takes the past arguments, formats them and places them in the string where the placeholders are.\n",
    "\n",
    "Different ways to format string:\n",
    "\n",
    "    1. Using format\n",
    "    2. Using %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is John, my age is 20\n",
      "I want 3 number of items 5 for 10 dollars\n"
     ]
    }
   ],
   "source": [
    "# String Formatting\n",
    "\n",
    "# Strings\n",
    "age = 20\n",
    "a = 3\n",
    "b = 5\n",
    "c = 10\n",
    "# {} - is a placeholder for a variable\n",
    "txt = \"My name is John, my age is {}\"\n",
    "order = \"I want {} number of items {} for {} dollars\"\n",
    "\n",
    "# Method - 1: Using format\n",
    "print(txt.format(age))\n",
    "print(order.format(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assignment - 1\n",
    "\n",
    "-> Explore other ways to reverse a String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orginal String: Example String\n",
      "Method - 1 (Using Slicing): gnirtS elpmaxE\n",
      "Method - 2 (Using 'reversed'): gnirtS elpmaxE\n",
      "Method - 3 (Using for loop): gnirtS elpmaxE\n",
      "Method - 4 (Using while loop): gnirtS elpmaxE\n",
      "Method - 5 (Using a Recursive function): gnirtS elpmaxE\n"
     ]
    }
   ],
   "source": [
    "# Other ways to reverse a String\n",
    "a_string = \"Example String\"\n",
    "print(f\"Orginal String: {a_string}\")\n",
    "\n",
    "# Method - 1: Using Slicing\n",
    "print(f\"Method - 1 (Using Slicing): {a_string[::-1]}\")\n",
    "\n",
    "# Method - 2: Using 'reversed'\n",
    "print((f\"Method - 2 (Using 'reversed'): {''.join(reversed(a_string))}\"))\n",
    "\n",
    "# Method - 3: Using for loop\n",
    "new_string = \"\"\n",
    "for _ in range(len(a_string) - 1, -1, -1):\n",
    "    new_string += a_string[_]\n",
    "print(f\"Method - 3 (Using for loop): {new_string}\")\n",
    "\n",
    "# Method - 4: Using while loop\n",
    "new_string = \"\"\n",
    "i = len(a_string) - 1\n",
    "while i >= 0:\n",
    "    new_string += a_string[i]\n",
    "    i -= 1\n",
    "print(f\"Method - 4 (Using while loop): {new_string}\")\n",
    "\n",
    "# Method - 5: Using a Recursive function\n",
    "def reverse_string(string_to_reverse):\n",
    "    if len(string_to_reverse) == 0:\n",
    "        return \"\"\n",
    "    else:\n",
    "        return string_to_reverse[-1] + reverse_string(string_to_reverse[:-1])\n",
    "\n",
    "print(f\"Method - 5 (Using a Recursive function): {reverse_string(a_string)}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}