Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings represents the group of character. Strings are enclose in double quotes or single quotes. The str data type represents a String.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single,Double, Triple, Double Triple Quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir\n",
      "Nasir\n",
      "'Nasir'\n",
      " Nasir\n"
     ]
    }
   ],
   "source": [
    "str1= 'Nasir'\n",
    "str2= \"Nasir\"\n",
    "str3= \"'Nasir'\"\n",
    "str4= \"\"\" Nasir\"\"\"\n",
    "print (str1)\n",
    "print (str2)\n",
    "print (str3)\n",
    "print (str4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello \"Nasir\" How are you!\n",
      " \n",
      "Hello 'Nasir' How are you!\n"
     ]
    }
   ],
   "source": [
    "# Double Quote inside Single Quote\n",
    "str5 = 'Hello \"Nasir\" How are you!'\n",
    "print (str5)\n",
    "\n",
    "print (\" \")\n",
    "\n",
    "# Single Quote inside Double Quotes\n",
    "str6 = \"Hello 'Nasir' How are you!\"\n",
    "print (str6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Memory Allocation\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1= 2114253125872\n",
      "str2= 2114253125872\n",
      "str3= 2114180902128\n"
     ]
    }
   ],
   "source": [
    "str1= 'Nasir'\n",
    "str2= \"Nasir\"\n",
    "str3= \"Python\"\n",
    "\n",
    "print (\"str1=\", id(str1))\n",
    "print (\"str2=\", id(str2))\n",
    "print (\"str3=\", id (str3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index\n",
    "#### Index represents the posittion number of characters in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n",
      " \n",
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "str1= 'Nasir'\n",
    "print (str1[0])\n",
    "print (str1[1])\n",
    "print (str1[2])\n",
    "print (str1[3])\n",
    "print (str1[4])\n",
    "\n",
    "print (\" \")\n",
    "\n",
    "print (str1[-5])\n",
    "print (str1[-4])\n",
    "print (str1[-3])\n",
    "print (str1[-2])\n",
    "print (str1[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Length\n",
    "#### Lenght of string represent the number of characters in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      " \n",
      "Length of given string is  5\n"
     ]
    }
   ],
   "source": [
    "str1= 'Nasir'\n",
    "n = len (str1)\n",
    "print (n)\n",
    "\n",
    "print (\" \")\n",
    "print (\"Length of given string is \", n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing String using Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n",
      " \n",
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n",
      "_\n",
      "A\n",
      "l\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "# Using for-loop without index\n",
    "str1= \"Nasir\"\n",
    "for i in str1:\n",
    "    print (i)\n",
    "\n",
    "print (\" \")\n",
    "\n",
    "# Using for-loop without index\n",
    "str2= \"Nasir_Ali\"\n",
    "n = len(str2)\n",
    "\n",
    "\n",
    "for i in range(n):\n",
    "    print(str2[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "# Using while-loop\n",
    "str1= 'Nasir'\n",
    "n = len(str1)\n",
    "#\n",
    "i=0\n",
    "while i<n:\n",
    "    print (str1[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutable & Immutable Object\n",
    "#### Mutable Object: Mutable object are those object whose vale or content can be changed  when it required.\n",
    "#### Ex:- List, Set, Dictionaries\n",
    "\n",
    "#### Immutable Object: Immutable object are those object whose vale or content cannot  be changed .\n",
    "#### Ex:- Number, String, Tuple\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Repitition Operator \n",
    "#### Repitition operator is used to repeat the string for several times. It is denoted by *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir Nasir Nasir Nasir Nasir \n"
     ]
    }
   ],
   "source": [
    "str1 = \"Nasir \"\n",
    "print (str1 * 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NaNaNaNaNa\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Nasir \"\n",
    "print (str1[0:2] * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenation Operator\n",
    "#### Concatenation operator is used to join two string. It is denoted by +\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir Ali\n"
     ]
    }
   ],
   "source": [
    "str1=\"Nasir \"\n",
    "str2=\"Ali\"\n",
    "print (str1 + str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir Ali\n"
     ]
    }
   ],
   "source": [
    "str1=\"Nasir \"\n",
    "str2=\"Ali\"\n",
    "\n",
    "joint_str = str1 + str2\n",
    "print (joint_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing String\n",
    "#### Comparing string is used to compare two string. Comparing operator are <,>,<=,>=,==,!=\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Nasir\"\n",
    "str2 = \"Nasir\"\n",
    "result = str1 == str2\n",
    "\n",
    "print (result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Nasir\"\n",
    "str2 = \"Nasirs\"\n",
    "result = str1 < str2\n",
    "\n",
    "print (result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Nasir\"\n",
    "str2 = \"Nasirs\"\n",
    "result = str1 > str2\n",
    "\n",
    "print (result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fornatting String\n",
    "#### There are three way to format a string\n",
    "#### 1. C-Style String Formatting \n",
    "#### 2. format () Method\n",
    "#### 3. f-String/ Formatted String Literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Funtions \n",
    "#### 1. upper () : This method is used to convert all character of a string into a uppercase\n",
    "#### 2. lower ():  This method is used to convert all character of a string into a uppercase \n",
    "#### 3. swapcase (): This method is used to convert all lower case character into uppercase and vice versa.\n",
    "#### 4. title (): This method is used to convert the string in such that each word in string will start with a capital letter and remaining will be small letter. \n",
    "#### 5. isupper (): This method is used to test whether given string is in upper case or not, it returns \"True\" if string contains at least one letter and all characters are in upper case else return \"False\".\n",
    "#### 6. islower (): This method is used to test whether given string is in lower case or not, it returns \"True\" if string contains at least one letter and all characters are in lower case else return \"False\".\n",
    "#### 7. istitle (): This method is used to test whether given string is in title format or not, it returns \"True\" if string contains at least one letter and each word of the string starts with a capital letter else return \"False\". \n",
    "#### 8. isdigit (): This method is used to returns \"True\" if the string contains only numeric digits (0 to 9) else returns \"False\".\n",
    "#### 9. isalpha (): This method is used to returns \"True\" if the string has at least one character and all are alphabets (A to Z or a to z) else reutrn \"False\".\n",
    "#### 10. isalnum (): This method is used to return \"True\" if the string has at least one character and all characters in the string are alphanumeric (A to Z or a to z and 0 to 9) else returns \"False\".\n",
    "#### 11. isspace (): This method is used to return \"True\" if the string contains only space else returns \"False\".\n",
    "#### 12. lstrip (): This method is used to remove the space which are left side of the string.\n",
    "#### 13. rstrip (): This method is used to remove the space which are right side of the string.\n",
    "#### 14. strip (): This method is used to remove the space from the both side of the string.\n",
    "#### 15. replace (): This method is used to replace a sub string in a string with another sub string.\n",
    "#### 16. split (): This method is used to split/break a string into peices. These pieces returs as a list. \n",
    "#### 17. join (): This method is used to join strings into one string.\n",
    "#### 18. startswith (): This method is used to check whether a string is starting with a substring or not. It returns \"True\" if the string starts with specified sub string. \n",
    "#### 19. endswith (): This method is used to check whether a string is ending with a substring or not. It returns \"True\" if the string ending with specified sub string. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without Upper Function: Nasir Ali\n",
      "With Upper Function: NASIR ALI\n"
     ]
    }
   ],
   "source": [
    "#upper () fucntion \n",
    "name = \"Nasir Ali\"\n",
    "print (\"Without Upper Function:\", name)\n",
    "print (\"With Upper Function:\", name.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without Lower Function: Nasir Ali\n",
      "With Lower Function: nasir ali\n"
     ]
    }
   ],
   "source": [
    "#lower () fucntion \n",
    "name = \"Nasir Ali\"\n",
    "print (\"Without Lower Function:\", name)\n",
    "print (\"With Lower Function:\", name.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without Swap Function: Nasir Ali\n",
      "With Swap Function: nASIR aLI\n"
     ]
    }
   ],
   "source": [
    "#swapcase () fucntion \n",
    "name = \"Nasir Ali\"\n",
    "print (\"Without Swap Function:\", name)\n",
    "print (\"With Swap Function:\", name.swapcase())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without Title Function: hello! nasir nli\n",
      "With Tilte Function: Hello! Nasir Nli\n"
     ]
    }
   ],
   "source": [
    "#title () fucntion \n",
    "name = \"hello! nasir ali\"\n",
    "print (\"Without Title Function:\", name)\n",
    "print (\"With Tilte Function:\", name.title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With isupper Function: True\n",
      "With isupper Function: False\n",
      "With isupper Function: False\n"
     ]
    }
   ],
   "source": [
    "#isupper () fucntion \n",
    "cap_letter = \"NASIR ALI\"\n",
    "small_letter = \"nasir ali\"\n",
    "mix_letter = \"Nasir Ali\"\n",
    "\n",
    "print (\"With isupper Function:\", cap_letter.isupper())\n",
    "print (\"With isupper Function:\", small_letter.isupper())\n",
    "print (\"With isupper Function:\", mix_letter.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With isupper Function: False\n",
      "With isupper Function: True\n",
      "With isupper Function: False\n"
     ]
    }
   ],
   "source": [
    "#islower () fucntion \n",
    "cap_letter = \"NASIR ALI\"\n",
    "small_letter = \"nasir ali\"\n",
    "mix_letter = \"Nasir Ali\"\n",
    "\n",
    "print (\"With isupper Function:\", cap_letter.islower())\n",
    "print (\"With isupper Function:\", small_letter.islower())\n",
    "print (\"With isupper Function:\", mix_letter.islower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With isupper Function: False\n",
      "With isupper Function: False\n",
      "With isupper Function: True\n"
     ]
    }
   ],
   "source": [
    "#istitle () fucntion \n",
    "cap_letter = \"NASIR ALI\"\n",
    "small_letter = \"nasir ali\"\n",
    "mix_letter = \"Nasir Ali\"\n",
    "\n",
    "print (\"With isupper Function:\", cap_letter.istitle())\n",
    "print (\"With isupper Function:\", small_letter.istitle())\n",
    "print (\"With isupper Function:\", mix_letter.istitle())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isdigit () function\n",
    "id_card = \"3420228767875\"\n",
    "id_card_with_dash = \"34202-2876787-5\"\n",
    "mix_num = \"Nasir Ali, 3420228767875\"\n",
    "print (id_card.isdigit())\n",
    "print (id_card_with_dash.isdigit())\n",
    "print (mix_num.isdigit())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isalpha () function\n",
    "name_without_space = \"NasirAli\"\n",
    "name_with_space = \"Nasir Ali\"\n",
    "mix = \"Nasir3420228767875\"\n",
    "print (name_without_space.isalpha())\n",
    "print (name_with_space.isalpha())\n",
    "print (mix.isalpha())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#isalnum () function\n",
    "name = \"Nasir\"\n",
    "num = \"3420228767875\"\n",
    "mix = \"Nasir3420228767875\"\n",
    "print (name.isalnum())\n",
    "print (num.isalnum())\n",
    "print (mix.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#isspace () function\n",
    "name_without_space = \"NasirAli\"\n",
    "name_with_space = \"Nasir Ali\"\n",
    "only_space = \" \"\n",
    "\n",
    "print (name_without_space.isspace())\n",
    "print (name_with_space.isspace())\n",
    "print (only_space.isspace())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without lstrip Function:       Nasir\n",
      "With lstrip Function: Nasir\n"
     ]
    }
   ],
   "source": [
    " #lstrip () function\n",
    "name = \"      Nasir\"\n",
    "print (\"Without lstrip Function:\", name)\n",
    "print (\"With lstrip Function:\", name.lstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without lstrip Function: Nasir           \n",
      "With lstrip Function: Nasir\n"
     ]
    }
   ],
   "source": [
    " #rstrip () function\n",
    "name = \"Nasir           \"\n",
    "print (\"Without lstrip Function:\", name)\n",
    "print (\"With lstrip Function:\", name.rstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without lstrip Function:          Nasir           \n",
      "With lstrip Function: Nasir\n"
     ]
    }
   ],
   "source": [
    " #strip () function\n",
    "name = \"         Nasir           \"\n",
    "print (\"Without lstrip Function:\", name)\n",
    "print (\"With lstrip Function:\", name.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yasir Ali\n",
      " \n",
      "Nasir Ali\n",
      "Yasir Ali\n"
     ]
    }
   ],
   "source": [
    "#replace () function\n",
    "name = \"Nasir Ali\"\n",
    "old = \"Nasir\"\n",
    "new = \"Yasir\"\n",
    "\n",
    "replaced_string = name.replace(old, new)\n",
    "print (replaced_string)\n",
    "\n",
    "print (\" \")\n",
    "\n",
    "# using another way\n",
    "str1 = name.replace (\"Nasir\", \"Yasir\")\n",
    "print (name)\n",
    "print (str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'How', 'are', 'you']\n",
      "['Nasir', 'Ali']\n"
     ]
    }
   ],
   "source": [
    "#split () function\n",
    "sentence = \"Hello-How-are-you\"\n",
    "str1 = sentence.split('-')\n",
    "print (str1)\n",
    "\n",
    "name = \"Nasir Ali\"\n",
    "str2 = name.split(\" \")\n",
    "print (str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Hello', 'How', 'Are', 'You')\n",
      "Hello_How_Are_You\n"
     ]
    }
   ],
   "source": [
    "#join () function\n",
    "name = ('Hello', 'How', 'Are', 'You')\n",
    "str1 = '_'.join(name)\n",
    "print (name)\n",
    "print (str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#startswith () function\n",
    "name = \"Hi How are you.\"\n",
    "print (name.startswith('Hi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#endwith () function\n",
    "name = \"Hi How are you.\"\n",
    "print (name.endswith('.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}