Useful Python String Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful String Methods in Python\n",
    " Learn about some of Python's built-in methods that can be used on strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell  \n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. center( )\n",
    "\n",
    "The `center()` method center aligns a string. The alignment is done using a specified character (whitespace is default)\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "str.center(length, fillchar), where :\n",
    "```\n",
    "* **length** is the length of the string [_Required_]\n",
    "* **fillchar** is the character which specifies the alignment [_Optional_]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'###algorithm###'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = 'algorithm'\n",
    "sentence.center(15,'#')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. count( )\n",
    "\n",
    "The `count()` method returns the count or the number of times a particular value appears in a string.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "str.count(value, start, end), where :\n",
    "```\n",
    "* **value** is the substring which is to be searched in the string [_Required_]\n",
    "* **start** is the starting index within the string where the search for the specified value starts [_Optional_]\n",
    "* **end** is the ending index within the string where the search for the specified value ends [_Optional_]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = 'She sells seashells by the seashore. The shells she sells are surely seashells'\n",
    "sentence.count('seashells')\n",
    "sentence.count('seashells',9,25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. find( ) \n",
    "\n",
    "The `find()` method returns the lowest index of a particular substring in a string. If the substring is not found, -1 is returned. \n",
    "\n",
    "### Syntax\n",
    "\n",
    "```\n",
    "str.count(value, start, end), where :\n",
    "```\n",
    "* **value** or substring which is to be searched in the string [_Required_]\n",
    "* **start** is the starting index within the string where the search for the specified value starts [_Optional_]\n",
    "* **end** is the ending index within the string where the search for the specified value ends [_Optional_]\n",
    "\n",
    "### Types\n",
    "**rfind()** : The rfind() method is similar to find() except that it returns the highest index value of the substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = 'She sells seashells by the seashore. The shells she sells are surely seashells'\n",
    "sentence.find('seashells')\n",
    "sentence.find('seashells',0,9)\n",
    "sentence.find('s',5,10)\n",
    "sentence.rfind('seashells')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. swapcase( )\n",
    "The `swapcase()` method returns a copy of the string with all its uppercase letters converted into lower case and vice versa.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.swapcase()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'qUEUE is ANOTHER fundamental DATA strUCTURE and is A CLOSE cousin OF THE stack'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = 'Queue IS another FUNDAMENTAL data STRucture AND IS a close COUSIN of the STACK'\n",
    "sentence.swapcase()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. startswith( ) and endswith( )\n",
    "\n",
    "The `startswith()` method returns True if the string starts with the specified value, otherwise it returns False.\n",
    "The `endswith()` function, on the other hand, returns True if the string endswith the specified value, else it returns False.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.startswith(value, start, end)\n",
    "string.endsswith(value, start, end)\n",
    "```\n",
    "* **value** is the string to look for in the string _[Required]_\n",
    "* **start** is the starting index within the string where the search for the specified value starts _[Optional]_\n",
    "* **end** is the ending index within the string where the search for the specified value ends _[Optional]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#string.startswith()\n",
    "\n",
    "sentence = 'Binary Search is a classic recursive algorithm'\n",
    "sentence.startswith(\"Binary\")\n",
    "sentence.startswith(\"Search\",7,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#string.endswith()\n",
    "sentence.endswith('classic')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. split( ) \n",
    "\n",
    "The `split()` method returns a list of words in a string where default separator is any whitespace.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.split(sep, maxsplit)`\n",
    "```\n",
    "* **sep**: The separator to be used for splitting the string. if nothing is specified, whitespace is the default separator[Optional]\n",
    "* **maxsplit**: denotes the number of splits. Default is -1 which means \"all occurrences\"[Optional]\n",
    "\n",
    "### Version\n",
    "**rsplit()**: splits a string from the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apples,', 'mangoes,', 'bananas,', 'grapes']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['apples', ' mangoes', ' bananas, grapes']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#string.split()\n",
    "\n",
    "fruits = 'apples, mangoes, bananas, grapes'\n",
    "fruits.split()\n",
    "fruits.split(\",\",maxsplit = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apples, mangoes, bananas', ' grapes']"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#string.rsplit()\n",
    "fruits.rsplit(\",\",maxsplit = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.String Capitalization\n",
    "\n",
    "### 1. capitalize()\n",
    "\n",
    "The **capitalize()** method capitalizes only the first character of the given string.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.capitalize()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'San francisco'"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"san francisco\".capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. upper( )\n",
    "\n",
    "The **upper()** method only capitalizes the first letter of the string.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.upper()\n",
    "```           \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SAN FRANCISCO'"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"san francisco\".upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. string.title( )\n",
    "\n",
    "The **title()** method capitalizes all the first letters of the string.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.title()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'San Francisco'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"san francisco\".title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. ljust( ) and rjust( )\n",
    "\n",
    "The **ljust()** method returns a left-justified version of the given string using a specified character, whitespace being default. The **rjust()** methods aligns the string to the right.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.rjust/ljust(length, character)\n",
    "```\n",
    "* **length**: length of the string which is to be returned _[Required]_\n",
    "* **character**: Character used for filling in the missing space where whitespace is default _[Optional]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Binary Search is a classic recursive algorithm\n"
     ]
    }
   ],
   "source": [
    "#str.rjust\n",
    "text = 'Binary Search'\n",
    "print(text.rjust(25),\"is a classic recursive algorithm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary Search             is a classic recursive algorithm\n"
     ]
    }
   ],
   "source": [
    "#str.ljust\n",
    "text = 'Binary Search'\n",
    "print(text.ljust(25),\"is a classic recursive algorithm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. strip( ) \n",
    "\n",
    "The **strip()** method returns a copy of the string with the leading and trailing characters removed. Default character to be removed is whitespace.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.strip(character)\n",
    "```\n",
    "* **character**: set of characters to be removed **[Optional]**\n",
    "\n",
    "### Versions\n",
    "```\n",
    "rstrip(): strips characters from the right of a string.\n",
    "lstrip(): strips characters from the left of a string.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Section 3.2.1 Issue #32'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#str.strip\n",
    "string = '#.......Section 3.2.1 Issue #32......'\n",
    "string.strip('.#!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'#.......Section 3.2.1 Issue #32'"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'Section 3.2.1 Issue #32......'"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#str.rstrip\n",
    "string.rstrip('.#!')\n",
    "string.lstrip('.#!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. zfill( )\n",
    "\n",
    "The **zfill()** method adds zeros(0) at the beginning of the string. The length of the returned string depends on the width provided.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "string.zfill(width)\n",
    "```\n",
    "**width**: specifies the length of the returned string. However, no zeros are added if the width parameter is less than the length of the original string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'007'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'-0021'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'0000Python'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'7'.zfill(3)\n",
    "'-21'.zfill(5)\n",
    "'Python'.zfill(10)\n",
    "'Python'.zfill(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}