G9.String method.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PROGRAM ON STRING METHODS"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Capitalize( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gourav\n"
     ]
    }
   ],
   "source": [
    "g1=(\"gourav\")\n",
    "print(g1.capitalize())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert of Lower( ) Case & Upper Case String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gourav\n",
      "GOURAV\n"
     ]
    }
   ],
   "source": [
    "g2=(\"GOURAV\")\n",
    "print(g2.lower())\n",
    "\n",
    "g3=(\"gourav\")\n",
    "print(g3.upper())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count( )Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "g5=(\"GOURAVFROOTI\")\n",
    "print(g5.count('R'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "INDEX( )METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "g6=(\"GOURAV\")\n",
    "print(g6.index('U'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FIND( ) METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "g7=(\"GOURAV\")\n",
    "print(g7.find('V'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "REPLACE( ) METHOD "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14-6-23\n"
     ]
    }
   ],
   "source": [
    "g8=(\"14/6/23\")\n",
    "print(g8.replace('/','-'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SPLIT( ) METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['GOURAV']\n"
     ]
    }
   ],
   "source": [
    "g9=(\"GOURAV\")\n",
    "print(g9.split('/'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "g12=(\"gourav\")\n",
    "print(g12.islower())\n",
    "\n",
    "g13=(\"GOURAV\")\n",
    "print(g13.isupper())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "STRING CONCATINATION AND REPLECATION METHODS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String Concatenation:\n",
    "\n",
    "String concatenation is the process of joining two or more strings together. In Python, you can concatenate strings using the + operator or by using the join() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Using the + operator\n",
    "str1 = \"Hello\"\n",
    "str2 = \"World\"\n",
    "result = str1 + \" \" + str2\n",
    "print(result)  \n",
    "# Output: Hello World\n",
    "\n",
    "# Using the join() method\n",
    "words = [\"Hello\", \"World\"]\n",
    "result = \" \".join(words)\n",
    "print(result)  \n",
    "# Output: Hello World\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String Replication:\n",
    "\n",
    "String replication is the process of repeating a string multiple times. You can do this using the * operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloHelloHello\n"
     ]
    }
   ],
   "source": [
    "# Replicating a string\n",
    "str1 = \"Hello\"\n",
    "result = str1 * 3\n",
    "print(result)  \n",
    "# Output: HelloHelloHello\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining Concatenation and Replication\n",
    "You can combine both operations to achieve more complex results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HaHaHa!\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Ha\"\n",
    "result = (str1 * 3) + \"!\"\n",
    "print(result)  \n",
    "# Output: HaHaHa!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In Python,\n",
    "\n",
    "strings have several methods that allow you to check specific properties of the string, such as whether the string consists of numbers, letters, or a combination of both. Here are some of the common string methods related to these checks:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1)str.isdigit():\n",
    "\n",
    "Returns True if all characters in the string are digits (0-9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"123\".isdigit())  \n",
    "print(\"123a\".isdigit())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2)str.isalpha():\n",
    "\n",
    "Returns True if all characters in the string are alphabetic (a-z, A-Z)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"abc\".isalpha())  \n",
    "print(\"abc123\".isalpha())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3)str.isalnum():\n",
    "\n",
    "Returns True if all characters in the string are alphanumeric (a-z, A-Z, 0-9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"abc123\".isalnum())  \n",
    "print(\"abc123!\".isalnum())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4)str.islower():\n",
    "\n",
    "Returns True if all characters in the string are lowercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"abc\".islower())  \n",
    "print(\"Abc\".islower())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5)str.isupper():\n",
    "\n",
    "Returns True if all characters in the string are uppercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"ABC\".isupper())  \n",
    "print(\"Abc\".isupper())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6)str.isspace():\n",
    "\n",
    "Returns True if all characters in the string are whitespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"   \".isspace())  \n",
    "print(\" abc \".isspace())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7)str.isnumeric():\n",
    "\n",
    "Returns True if all characters in the string are numeric characters. This includes digits, but also includes other numeric characters such as fractions, subscripts, superscripts, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"123\".isnumeric()) \n",
    "print(\"½\".isnumeric())    \n",
    "#You can use the Unicode escape sequence \\u00BD to represent ½"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8)str.isdecimal():\n",
    "\n",
    "Returns True if all characters in the string are decimal characters. Decimal characters are a subset of numeric characters that are strictly digits (0-9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"123\".isdecimal())  \n",
    "print(\"½\".isdecimal())    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9)str.istitle():\n",
    "\n",
    "Returns True if the string is in title case (i.e., the first letter of each word is uppercase and all other letters are lowercase)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\".istitle())  \n",
    "print(\"Hello world\".istitle())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10)str.isidentifier():\n",
    "\n",
    "Returns True if the string is a valid identifier in Python, meaning it can be used as a variable name (does not start with a digit, only contains alphanumeric characters and underscores)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"variable_name\".isidentifier())  # True\n",
    "print(\"123abc\".isidentifier())  # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Here’s a rundown of some common string methods in Python that deal with trimming whitespace and justifying text:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1)str.rstrip()\n",
    "\n",
    "Removes trailing (right-side) whitespace or specified characters from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello World   \"\n",
    "print(text.rstrip())  \n",
    "\n",
    "# Removing specific characters\n",
    "text = \"Hello World!!!\"\n",
    "print(text.rstrip(\"!\"))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2)str.lstrip()\n",
    "\n",
    "Removes leading (left-side) whitespace or specified characters from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "text = \"   Hello World\"\n",
    "print(text.lstrip())  \n",
    "\n",
    "# Removing specific characters\n",
    "text = \"###Hello World\"\n",
    "print(text.lstrip(\"#\"))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3)str.strip()\n",
    "\n",
    "Removes leading and trailing whitespace or specified characters from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "text = \"   Hello World   \"\n",
    "print(text.strip())  \n",
    "\n",
    "# Removing specific characters\n",
    "text = \"!!!Hello World!!!\"\n",
    "print(text.strip(\"!\"))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4)str.rjust(width, fillchar)\n",
    "\n",
    "Right-justifies the string within a given width, padding with a specified character (default is space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Hello\n",
      "-----Hello\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello\"\n",
    "print(text.rjust(10))  \n",
    "\n",
    "# With a specified fill character\n",
    "print(text.rjust(10, \"-\"))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5)str.ljust(width, fillchar)\n",
    "\n",
    "Left-justifies the string within a given width, padding with a specified character (default is space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello     \n",
      "Hello-----\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello\"\n",
    "print(text.ljust(10))  \n",
    "\n",
    "# With a specified fill character\n",
    "print(text.ljust(10, \"-\")) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6)str.center(width, fillchar)\n",
    "\n",
    "\n",
    "Centers the string within a given width, padding with a specified character (default is space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Hello   \n",
      "--Hello---\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello\"\n",
    "print(text.center(10))  \n",
    "\n",
    "# With a specified fill character\n",
    "print(text.center(10, \"-\"))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7)str.zfill(width)\n",
    "\n",
    "Pads the string on the left with zeros until it reaches the specified width. Works well with numeric strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00042\n",
      "-0042\n"
     ]
    }
   ],
   "source": [
    "text = \"42\"\n",
    "print(text.zfill(5))  \n",
    "\n",
    "# With a negative sign\n",
    "text = \"-42\"\n",
    "print(text.zfill(5)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8)str.partition(separator)\n",
    "\n",
    "Splits the string at the first occurrence of the separator, returning a tuple of three elements: (before separator, separator, after separator)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Hello', ',', ' world')\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, world\"\n",
    "print(text.partition(\",\"))  # Output: ('Hello', ',', ' world')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9)str.rpartition(separator)\n",
    "\n",
    "Splits the string at the last occurrence of the separator, returning a tuple of three elements: (before separator, separator, after separator)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Hello, world', ',', ' again')\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, world, again\"\n",
    "print(text.rpartition(\",\"))  # Output: ('Hello, world', ',', ' again')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10)str.splitlines(keepends=False)\n",
    "\n",
    "Splits the string at line breaks, returning a list of lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'World', 'Again']\n",
      "['Hello\\n', 'World\\n', 'Again']\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello\\nWorld\\nAgain\"\n",
    "print(text.splitlines())  # Output: ['Hello', 'World', 'Again']\n",
    "\n",
    "# Keeping line breaks\n",
    "print(text.splitlines(True))  # Output: ['Hello\\n', 'World\\n', 'Again']\n"
   ]
  }
 ],
 "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}