String.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "12e2df18",
   "metadata": {},
   "source": [
    "## STRING\n",
    "\n",
    "A string is a seqence of characters\n",
    "'' or '' '' or ''' '''\n",
    "strings are ordered, that means we can index[] or do slicing []\n",
    "strings are imutable(cannot be changed once created)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60808a3",
   "metadata": {},
   "source": [
    "# How to create a string in Python?\n",
    "\n",
    "Strings can be created by enclosing characters inside a single quote or double-quotes. Even triple quotes can be used in Python but generally used to represent multiline strings and docstrings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7f60b44d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello, welcome to\n",
      "           the world of Python\n"
     ]
    }
   ],
   "source": [
    "# defining strings in Python\n",
    "# all of the following are equivalent\n",
    "my_string = 'Hello'\n",
    "print(my_string)\n",
    "\n",
    "my_string = \"Hello\"\n",
    "print(my_string)\n",
    "\n",
    "my_string = '''Hello'''\n",
    "print(my_string)\n",
    "\n",
    "# triple quotes string can extend multiple lines\n",
    "my_string = \"\"\"Hello, welcome to\n",
    "           the world of Python\"\"\"\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3340fd31",
   "metadata": {},
   "source": [
    "# HOW to Access the string?\n",
    "\n",
    "We can access individual characters using indexing and a range of characters using slicing. Index starts from 0. Trying to access a character out of index range will raise an IndexError. The index must be an integer. We can't use floats or other types, this will result into TypeError.\n",
    "\n",
    "Python allows negative indexing for its sequences.\n",
    "\n",
    "The index of -1 refers to the last item, -2 to the second last item and so on. We can access a range of items in a string by using the slicing operator :(colon)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7289b604",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str =  Data science\n",
      "str[0] =  D\n",
      "str[-1] =  e\n",
      "str[1:5] =  ata \n",
      "str[5:-2] =  scien\n"
     ]
    }
   ],
   "source": [
    "#Accessing string characters in Python\n",
    "str = 'Data science'\n",
    "print('str = ', str)\n",
    "\n",
    "#first character\n",
    "print('str[0] = ', str[0])\n",
    "\n",
    "#last character\n",
    "print('str[-1] = ', str[-1])\n",
    "\n",
    "#slicing 2nd to 5th character\n",
    "print('str[1:5] = ', str[1:5])\n",
    "\n",
    "#slicing 6th to 2nd last character\n",
    "print('str[5:-2] = ', str[5:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a7646eb",
   "metadata": {},
   "source": [
    "# Python String Operations\n",
    "\n",
    "\n",
    "Joining of two or more strings into a single one is called concatenation.\n",
    "\n",
    "The + operator does this in Python. Simply writing two string literals together also concatenates them.\n",
    "\n",
    "The * operator can be used to repeat the string for a given number of times.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c43f5587",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Data Science'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1. concatenation of two strings\n",
    "\n",
    "str1= \"Data\"\n",
    "str2= \"Science\"\n",
    "\n",
    "result=str1+\" \"+str2\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e3f8c1cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataDataDataDataData\n"
     ]
    }
   ],
   "source": [
    "print(str1*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aa3e615",
   "metadata": {},
   "source": [
    "# Iterating through a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "db1e95c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "p\n",
      "p\n",
      "l\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "word =\"Apple\"\n",
    "for i in word:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c089f39",
   "metadata": {},
   "source": [
    "# String inbuilt() functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd7122d",
   "metadata": {},
   "source": [
    "1. lower()\n",
    "\n",
    "def- conver all characters wchich are in uppercase to lower case.\n",
    "\n",
    "syntax - string.lower()\n",
    "\n",
    "parametrs-no parameters\n",
    "\n",
    "return- returns a string in lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6067dbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this should be in lowercase'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_1=\"THIS SHOULD BE IN LOWERCASE\"\n",
    "example_1.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c800f3d",
   "metadata": {},
   "source": [
    "2. islower()\n",
    "\n",
    "def- the method returns true if all aplhabets are in lowercase else false\n",
    "\n",
    "syntax- string.islower()\n",
    "\n",
    "parameter-no\n",
    "\n",
    "return- bool value ie True or false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "67035685",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_second=\" This is good\"\n",
    "example_second.islower()   # Bcz all characters are not lower"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a31a075d",
   "metadata": {},
   "source": [
    "3. Upper()\n",
    "\n",
    "def- the method returns a string with all uppercase char\n",
    "\n",
    "syntax- string.upper()\n",
    "\n",
    "parameter-no\n",
    "\n",
    "return- uppercase string\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "38aa0c39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS GOOD'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_second=\"this is good\"\n",
    "example_second.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25290e5c",
   "metadata": {},
   "source": [
    "4.isupper()\n",
    "\n",
    "def- the method returns True if all the char are in uppercase\n",
    "\n",
    "syntax- string.isupper()\n",
    "\n",
    "parameter-no\n",
    "\n",
    "return- True if the string is in uppercase else false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e27fedbb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_three='THIS IS GOOD'\n",
    "example_three.isupper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78f0b8e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "5. Capitalize()\n",
    "\n",
    "def- the method returns string wch has the first char in upercase.\n",
    "\n",
    "syntax- string.capitalize()\n",
    "\n",
    "parameter-no\n",
    "\n",
    "return- a string with first letter or char in uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0b9a104b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love python'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence= \"i love Python\"\n",
    "sentence.capitalize()     # string with first letter capital all letter will be small"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1893c861",
   "metadata": {},
   "source": [
    "6. Count()\n",
    "\n",
    "def- returns the no of occurrences of a substring in given string\n",
    "\n",
    "syntax- string.count()\n",
    "\n",
    "parameter-substring- string whos count needs to be found - start(optional) - staring index of string where search starts -end(optional) -ending index of string where search ends\n",
    "\n",
    "return- returns the no of occurrences substring in given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8a4994c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "messge=\"Python is very popular programming language and Python is easy to learn\"\n",
    "messge.count(\"p\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2cd825",
   "metadata": {},
   "source": [
    "7. find()\n",
    "\n",
    "def- find method returns the index of first occurrance of the substring(if found) and if not found then return -1\n",
    "\n",
    "syntax- string.find()\n",
    "\n",
    "parameter-substring- string which needs to be searched - start(optional) - staring index of string where search starts -end(optional) -ending index of string where serach ends\n",
    "\n",
    "return- returns the index if found and if not then -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3dac0a20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "messge=\"Python is very popular programming language and Python is easy to learn\"\n",
    "\n",
    "messge.find(\"p\")   # it will gave the first index position in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6324a20c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "messge.find(\"p\",16,71)  # here we have to search index value from 16 position so here we use 16 as an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9e8d6088",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "messge.find(\"z\") # here z is not found in this message so it returns as -1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bf6a9e6",
   "metadata": {},
   "source": [
    "8.Index ()\n",
    "\n",
    "def - method returns the index of a substring inside the string but if not found rasie the exception\n",
    "\n",
    "syntax- string.index()\n",
    "\n",
    "parameter-substring- string which needs to be searched - start(optional) - staring index of string where search starts -end(optional) -ending index of string where serach ends\n",
    "\n",
    "returns- index if found and exception if not found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cd7dbe99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text= \"python is fun\"\n",
    "text.index(\"is\",0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "67b9e2b0",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[11], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mtext\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mz\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "text.index(\"z\") \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b7acf24",
   "metadata": {},
   "source": [
    "9. Center()\n",
    "\n",
    "def- method returns a new centered string after padding it with specified characters.\n",
    "\n",
    "syntax- string.centre() \n",
    "\n",
    "parameters- width- length of the string with padded characters fillchar(optional)-padding character\n",
    "\n",
    "returns- a string padded with specfied fill char\n",
    "\n",
    "#note- the center method doesnt modify the orginal string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ce890336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                      python                      \n",
      "**********************python**********************\n"
     ]
    }
   ],
   "source": [
    "my_txt=\"python\"\n",
    "print(my_txt.center(50))\n",
    "print(my_txt.center(50,\"*\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4162505",
   "metadata": {},
   "source": [
    "10. endswith()\n",
    "\n",
    "def- The method returns True if the strings end with the specfied suffix, if not then false\n",
    "\n",
    "syntax-string.endswith(\n",
    "\n",
    "parameter-suffix- string to be checked start end\n",
    "\n",
    "returns- True and fasle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7b99d80d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "website_name=\"www.instagram.com\"\n",
    "website_name.endswith(\".com\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a631cd",
   "metadata": {},
   "source": [
    "11. Startswith()\n",
    " \n",
    "def- The method returns True if the strings end with the specfied suffix, if not then false\n",
    "\n",
    "syntax-string.Startswith()\n",
    "\n",
    "parameter-suffix- string to be checked start end\n",
    "\n",
    "returns- True and fasle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5329cee4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "website_name=\"www.instagram.com\"\n",
    "website_name.startswith(\"www.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4adce42",
   "metadata": {},
   "source": [
    "12. split()\n",
    "\n",
    "string -list -----split()\n",
    "\n",
    "list - string -----join()\n",
    "\n",
    "def - Method breaks up a string at specified separator and returns a list of string\n",
    "\n",
    "parameters- Separator-delimiter at wch splits occurs maxsplit- max no of splits\n",
    "\n",
    "retun- list of strings\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e4fba43a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['python', 'is', 'a', 'fun', 'programming', 'language']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text=\"python is a fun programming language\"\n",
    "text.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9f320573",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "['python', 'is', 'a', 'fun programming language']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "text=\"python*is*a*fun programming language\"\n",
    "print(type(text))\n",
    "a=text.split(\"*\")  # here we pass * as a arg with split so * will remove and new list is formed\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3e0eb5fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['D', 'a', 't', 'a', 's', 'c', 'i', 'e', 'n', 'c', 'e']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_subject=\"Datascience\"\n",
    "list(my_subject)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a7f91f",
   "metadata": {},
   "source": [
    "13. Splitlines()\n",
    "\n",
    "<Methods slits the string at line breaks and returs a list of lines in the string --> -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a6e53a7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milk\n",
      "Bread\n",
      "butter\n"
     ]
    }
   ],
   "source": [
    "Our_grocery=\"Milk\\nBread\\nbutter\"\n",
    "print(Our_grocery)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bf3bb2a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Milk', 'Bread', 'butter']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Our_grocery.splitlines() # so it will returns a list of lines"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4ef0784",
   "metadata": {},
   "source": [
    "14. strip()\n",
    "\n",
    "def- the method returns a copy of the string by removing the leading and trailing characters(based on the subvstring passed)\n",
    "​\n",
    "parameter- Char deafult-space\n",
    "​\n",
    "return-\n",
    "​"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a6760bb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11111123456411111111'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string_3=\"XXXXXX11111123456411111111XXXX\"\n",
    "\n",
    "my_string_3.strip(\"X\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ff91396",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}