Strings_Team2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# What is a string?\n",
    "  -  String is created or represented with single or double quotes\n",
    "  -  String can possess single or group of character, words and lines\n",
    "  -  String in Python is considered as an array, hence each character possesses a position is string\n",
    "  -  There is no 'Character' datatype in Python, single character is a string with length 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# String created with single quotes\n",
    "# Strings can be displayed using print() function\n",
    "String = 'Hello World'\n",
    "print(String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# String created with double quotes\n",
    "# Strings can be displayed using print() function\n",
    "String = \"Hello World\"\n",
    "print(String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World,\n",
      "This is a\n",
      "Multi line String \n"
     ]
    }
   ],
   "source": [
    "# Multiline Strings are created with three sinle or double quotes\n",
    "multi_line_str ='''Hello World,\n",
    "This is a\n",
    "Multi line String '''\n",
    "print(multi_line_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# Python len() function returns lenght of a string\n",
    "\n",
    "String = 'Hello World'\n",
    "print(len(String))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Element:  H\n",
      "Last Element:  d\n"
     ]
    }
   ],
   "source": [
    "# String is an Array\n",
    "# Square brackets can be used to access elements in a string\n",
    "# First element of a String is addressed as index 0 and last element with -1\n",
    "\n",
    "String = 'Hello World'\n",
    "print('First Element: ',String[0])\n",
    "print('Last Element: ',String[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Word:  Hello\n"
     ]
    }
   ],
   "source": [
    "# Slicing in Array\n",
    "# Note last index is excluded in sclicing, Eg: String[0:5] - elements from O ... 4 indices are printing excluding 5\n",
    "\n",
    "String = 'Hello World'\n",
    "print('First Word: ', String[0:5]) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World"
     ]
    }
   ],
   "source": [
    "# Since a string is treated as Array in Python, looping through a string is possible\n",
    "\n",
    "String = 'Hello World'\n",
    "for i in String:\n",
    "    print(i,end='')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PythonJupyter\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'PythonPythonPython'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#String Concatenation using ‘+’:  Used to concatenate string values into a single string value\n",
    "\n",
    "coding_lang=\"Python\"\n",
    "note_book=\"Jupyter\"\n",
    "ccstr=coding_lang+note_book\n",
    "print(ccstr)\n",
    "       \n",
    "#String repetition using ‘*’: Used to repeat a string value a given number of times\n",
    "\n",
    "coding_lang=\"Python\"\n",
    "coding_lang*3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check a string - a string can be checked for a certain element or word using '\n",
    "\n",
    "String = 'Hello World'\n",
    "print('Hello' in String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    }
   ],
   "source": [
    "if 'Hello' in String:\n",
    "        print('Yes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Functions"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# There are more than 40 built in functions that can be used on strings\n",
    "# Important - all string functions return new string, do not change the original string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "hello World\n"
     ]
    }
   ],
   "source": [
    "# capitalize() - Converts the first character to upper case\n",
    "# syntax: string.capitalize()\n",
    "\n",
    "String = 'hello World'\n",
    "print(String.capitalize())\n",
    "\n",
    "print(String) # Original string is unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello  world\n",
      "the bulss is bright\n"
     ]
    }
   ],
   "source": [
    "# casefold() - Converts string into lower case\n",
    "# syntax: string.casefold()\n",
    "\n",
    "String = 'HELLO  WORLD'\n",
    "print(String.casefold())\n",
    "\n",
    "string2 = 'the bulß is bright'\n",
    "print(string2.casefold())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "****Hello World*****\n",
      "                   Hello World                    \n"
     ]
    }
   ],
   "source": [
    "# center() - Returns a centered string\n",
    "# syntax: string.center(length, character) \n",
    "# length - Required, length of returned string\n",
    "# character - Optional, character that is filled on the left and right of the centered string. Default ' ' (space) is filled  \n",
    "\n",
    "String = 'Hello World'\n",
    "print(String.center(20,'*'))\n",
    "\n",
    "String = 'Hello World'\n",
    "print(String.center(50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# count() - Returns the number of times a specified value occurs in a string\n",
    "# syntax: string.count(value, start, end)\n",
    "# value  - Required, the element that needs to be looked and counted for\n",
    "# start - Optional, the start position for counting. Default is 0 (start of the string) \n",
    "# end - Optional, the ending position for counting, Default is end of the string\n",
    "\n",
    "String = 'Hello World'\n",
    "print(String.count('o')) # with default start and end\n",
    "\n",
    "String = 'Hello World'\n",
    "print(String.count('o',4,7)) # with start position and end position defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#endswith() -  this method returns True if a string ends with any value specified, otherwise it returns a False.\n",
    "# syntax - string.endswith(value, start, end)\n",
    "\n",
    "stmt = \"Paris is a beautiful city*\"\n",
    "\n",
    "x = stmt.endswith(\"*\")\n",
    "print(x)\n",
    "       \n",
    "y = stmt.endswith(\"city*\", 25, 5)\n",
    "print(x)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "-1\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "# find() - this method finds the first occurrence of the specified value and returns -1 if the value is not found\n",
    "# syntax - string.find(value to find, start, end)\n",
    "\n",
    "stmt = 'Paris is a clean and beautiful city'\n",
    "\n",
    "x = stmt.find(\"e\")\n",
    "print(x)\n",
    "       \n",
    "z = stmt.find(\"e\", 5, 10)\n",
    "print(z)\n",
    "       \n",
    "c = stmt.find(\"e\", 5, 15)\n",
    "print(c)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paris     is   a    beautiful city\n",
      "Paris               is                  a                   beautiful           city\n"
     ]
    }
   ],
   "source": [
    "# expandtabs() - this method sets the tab size to the specified number of whitespaces.\n",
    "# syntax - string.expandtabs(tabsize)\n",
    "stmt = \"Paris\\tis\\ta\\tbeautiful\\tcity\"\n",
    "\n",
    "print(stmt.expandtabs(5))\n",
    "     \n",
    "\n",
    "print(stmt.expandtabs(20))\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This',\n",
       " 'is',\n",
       " 'an',\n",
       " 'encrypted',\n",
       " 'message',\n",
       " 'for',\n",
       " 'string',\n",
       " 'functions,',\n",
       " 'Do',\n",
       " 'not',\n",
       " 'compile',\n",
       " 'it']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split() - this method splits a string into a list\n",
    "# string.split(separator,max)\n",
    "string1 = \"This is an encrypted message for string functions, Do not compile it\"\n",
    "string1.split()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Yet another reminder',\n",
       " ' do not compile',\n",
       " ' unless you run the browser in incognito mode']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string2= \"Yet another reminder, do not compile, unless you run the browser in incognito mode\"\n",
    "string2.split(\",\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "THIS IS AN ENCRYPTED MESSAGE FOR STRING FUNCTIONS, DO NOT COMPILE IT\n"
     ]
    }
   ],
   "source": [
    "# upper() - this method returns a string with uppercase characters\n",
    "# syntax - string.upper()\n",
    "stmt = \"This is an encrypted message for string functions, Do not compile it\"\n",
    "\n",
    "x=stmt.upper()\n",
    "\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is an encrypted message for string functions, do not compile it\n"
     ]
    }
   ],
   "source": [
    "# lower () - this method returns a string with uppercase characters\n",
    "# syntax - string.lower()\n",
    "stmt = \"This is an encrypted message for string functions, Do not compile it\"\n",
    "\n",
    "x=stmt.lower()\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a good course\n"
     ]
    }
   ],
   "source": [
    "# join() - this method joins iterable items into a single string\n",
    "# syntax - string.join(iterable)\n",
    "string2=[\"This\", \"is\",\"a\",\"good\",\"course\"]\n",
    "print(' '.join(string2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SMALLANDcapital\n",
      "ALLSMALLLETTERS\n"
     ]
    }
   ],
   "source": [
    "# swapcase() - this method converts all uppercase characters to lowercase and vice versa of the given string, and returns it.\n",
    "# syntax - string_name.swapcase() \n",
    "string = \"smallandCAPITAL\"\n",
    "\n",
    "# prints after swappong all cases \n",
    "\n",
    "print(string.swapcase()) \n",
    "string = \"allsmallletters\"\n",
    "print(string.swapcase())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***goals\n",
      "goals***\n",
      "   goals\n"
     ]
    }
   ],
   "source": [
    "# rjust () and ljust()  - these methods return a new string of given length after substituting a given character in left side of original string.\n",
    "# syntax - string.rjust(length, fillchar)\n",
    "\n",
    "string = 'goals'\n",
    "length = 8\n",
    "fillchar = '*'\n",
    "\n",
    "print(string.rjust(length, fillchar))\n",
    "\n",
    "print(string.ljust(length, fillchar))\n",
    "\n",
    "print(string.rjust(length))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Team2, Currently presenting the string functions.\n",
      "This article is written in Python\n",
      "There are 4 members in Team 2!\n"
     ]
    }
   ],
   "source": [
    "# str.format() - this method lets us concatenate elements within a string through positional formatting.\n",
    "# Syntax: { }.format(value) \n",
    "# Parameters: (value): Can be an integer, floating point numeric constant, string, characters or even variables.\n",
    "#Returntype: Returns a formatted string with the value passed as parameter in the placeholder position.\n",
    "\n",
    "\n",
    "# using format option in a simple string \n",
    "print (\"{}, Currently presenting the string functions.\"\n",
    "                        .format(\"Team2\")) \n",
    "\n",
    "# using format option for a \n",
    "# value stored in a variable \n",
    "str = \"This article is written in {}\"\n",
    "print (str.format(\"Python\")) \n",
    "\n",
    "# formatting a string using a numeric constant \n",
    "print (\"There are {} members in Team 2!\".format(4)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Paris is a beautiful cit\\\\u20a4'\n",
      "b'Paris is a beautiful cit'\n",
      "b'Paris is a beautiful cit\\xe2\\x82\\xa4'\n"
     ]
    }
   ],
   "source": [
    "# encode() - this function is used for encoding a string in any particular format.\n",
    "# string.encode(encoding=encoding-format,errors=errors)\n",
    "#‘encoding’ can be any of these values: 'UTF-8'  (Default) , ‘ascii’ etc \n",
    "#‘errors’ can be any of these values:\n",
    "#'backslashreplace' -  uses a backslash in place of error\n",
    "#'ignore'-  ignores the character in place of error\n",
    "#'namereplace' -  replaces the character in place of error\n",
    "#'strict'-  default error display \n",
    "#'replace' -  replaces the error character with a question mark\n",
    "#'xmlcharrefreplace' -  replaces the error character with an xml character\n",
    "\n",
    "stmt = 'Paris is a beautiful cit₤'\n",
    "\n",
    "print(stmt.encode(encoding=\"ascii\",errors=\"backslashreplace\"))\n",
    "\n",
    "print(stmt.encode(encoding=\"ascii\",errors=\"ignore\"))\n",
    "\n",
    "print(stmt.encode(encoding=\"UTF-8\",errors=\"strict\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string before translating is : lifeisgood\n",
      "The string after translating is : lifeisfood\n"
     ]
    }
   ],
   "source": [
    "#translate() - this method returns a string that is modified string of given string according to given translation mappings.\n",
    "# syntax - string.translate(mapping)\n",
    "\n",
    "# specifying the mapping using ASCII \n",
    "#table = { ord('g') : ord('f')}\n",
    "table = { 103 : 102}\n",
    "#Target string \n",
    "trg = \"lifeisgood\"\n",
    "#Printing original string\n",
    "print (\"The string before translating is : \", end =\"\")  \n",
    "print (trg)  \n",
    "#Using translate() to make translations\n",
    "print (\"The string after translating is : \", end =\"\")  \n",
    "print (trg.translate(table))\n"
   ]
  },
  {
   "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.3"
  },
  "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": 4
}