Python_Notes_by_Saket_Savarn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SnF9NXXNTzvH"
   },
   "source": [
    "<h1><center><font color = \"red\"><hr><b> Python 3.7 Class Notes </font></center></b></h1><hr>\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XW_hO9reTziP"
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "<h1> Contents : </h1><br>\n",
    "\n",
    "<a href=\"#Note from the Author\">Note from the Author</a>\n",
    "<br>\n",
    "<br>\n",
    "1. <a href=\"#1. Introduction to Python\">Introduction to Python</a><br>\n",
    "2. <a href=\"#2. Features of Python\">Features of Python</a><br>\n",
    "3. <a href=\"#3. Domain of Python\">Domain of Python (What is Python used for?)</a><br>\n",
    "4. <a href=\"#4. Installing and setting-up Python\">Installing and setting up Python</a><br><br>\n",
    "5. <a href=\"#5. Python Basic Fundamentals\">Python Basic Fundamentals (Syntax Basics)</a><br>\n",
    "    a. <a href=\"#5A Flow of Code\">Flow of Code</a><br>\n",
    "    b. <a href=\"#5B Semi-colons in Python\">Semi-colons in Python</a><br>\n",
    "    c. <a href=\"#5C Indentation in Python\">Indentation in Python</a><br><br>\n",
    "6. <a href=\"#6 Commenting in Python\">Commenting in Python</a><br>\n",
    "    a. <a href=\"#6A Single line commenting in Python\">Single-line commenting in Python</a><br>\n",
    "    b. <a href=\"#6B Multi-line commenting in Python\">Multi-line commenting in Python</a><br><br>\n",
    "7. <a href=\"#7 Variables & Variable Assignment in Python\">Variables & Variable Assignment in python</a><br><br>\n",
    "8. <a href=\"#8 Print function in Python\">Print function in Python</a><br>\n",
    "    a. <a href=\"#8A Single-line printing in Python\">Single-line printing in Python</a><br>\n",
    "    b. <a href=\"#8B Escape sequence in Python\">Escape Sequence in Python</a><br>\n",
    "    c. <a href=\"#8C Multi-line printing in Python\">Multi-line printing in Python</a><br><br>        \n",
    "\n",
    "9. <a href=\"#9 Primary data types in Python\">Primary Data-types in Python</a><br>\n",
    "    a. <a href=\"#9A Integer data type\">Integer Data-Type</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;i. <a href=\"#9A i. Addition\">Addition Operator</a>(+)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;ii. <a href=\"#9A ii. Subraction\">Subraction Operator</a>(-)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;iii. <a href=\"#9A iii. Multiplication\">Multiplication Operator</a>(\\*)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;iv. <a href=\"#9A iv. Division\">Division Operator</a>(/)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;v. <a href=\"#9A v. Double Division\">Double Division Operator</a>(//)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;vi. <a href=\"#9A vi. Modulus\">Modulus Operator</a>(%)<br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;vii. <a href=\"#9A vii. Exponential\">Exponential Operator</a>(\\**)<br>\n",
    "    b. <a href=\"#9B Float data type\">Float Data-Type</a><br>\n",
    "    c. <a href=\"#9C String data type\">String Data-Type</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;i. <a href=\"#9C i. Declaring string values\">Declaring String Values</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;ii. <a href=\"#9C ii. String concatenation in python\">String Concatenation</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;iii. <a href=\"#9C iii. Indexing and slicing strings\">Indexing & Slicing Strings</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;iv. <a href=\"#9C iv. String properties\">String Properties</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;v. <a href=\"#9C v. String methods & functions\">Basic str methods & functions</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;vi. <a href=\"#9C vi. String methods\">Methods used with str</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;> <a href=\"#9C vi.> Len and type\">Some Important Functions in Python (len() & type())</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;vii. <a href=\"#9C vii.String functions\">Functions used with str</a><br>\n",
    "    d. <a href=\"#9D Boolean data type\">Boolean Data-Type</a><br>\n",
    "    &nbsp;&nbsp;&nbsp;&nbsp;i. <a href=\"#9D i. Comparison Operators\">Comparison Operators in Python</a><br>\n",
    "    e. <a href=\"#9E Complex data type\">Complex Number Data-Type</a><br>\n",
    "    f. <a href=\"#9F None data type\">None Data Type</a><br><br>\n",
    "10. <a href=\"#10. Looping Statements in Python\">Looping Statements in Python (For & While Loops)</a><br>\n",
    "    a. <a href=\"#10. i Need for looping statements in python\">Need of Looping Statements</a><br>\n",
    "    b. <a href=\"#10. ii For loop staments\">For Loops in Python(Syntax & Usage)</a><br>\n",
    "    c. <a href=\"#10. iii Nested for loop\">Nested For Loops</a><br><br>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5WcPOarJMXJo"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"Note from the Author\"></a>\n",
    "\n",
    "---\n",
    "<h3><b>Note from the Author</b></h3>\n",
    "\n",
    "---\n",
    "\n",
    "Hi! My name is [Saket Savarn](https://outcastdreamer.github.io/)!!<br>I am currently studying in my 3rd Year of B.Tech CSe at REVA University.\n",
    "The reason for me writing and documenting these Python Notes is to make it easier for me to provide the notes for the workshops and my internships where I teach Python frequently.<br>\n",
    "It also is for my reference purposes so that I can refer to all the concepts I have studied and also because it reinforces my python concepts as well.<br>\n",
    "Having said that I am pretty sure there will be bugs, grammatical errors, and few other kinds of errors here and there that I still need to verify and rectify. <br>\n",
    "In case you come across such bugs or errors feel free to email me at saketsavarn07@gmail.com and I will rectify them as soon as possible.\n",
    "<br>\n",
    "In the end I hope the notes are a useful resource to you and that my sessions where helpful in getting you started with python.<br>\n",
    "I am also sorry for the huge delay it takes me in updating these notes. As I said before, I am held busy by my multiple internships and workshops at a time and hence don't get the time to keep updating it, but I still try my best to update it whenever I get the time.\n",
    "<br>\n",
    "With all that done, I hope you keep learning!!<br>\n",
    "<br>\n",
    "<b><u>Contact Info + Me around the web</u> : </b>\n",
    "<ul><li><a href =\"https://www.instagram.com/outcast_dreamer/\">  Instagram or @outcast_dreamer </a></li>\n",
    "<li><a href=\"https://github.com/outcastdreamer\">Github Profile</a></li>\n",
    "<li>Email : <a href=\"\">saketsavarn07@gmail.com</a></li>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h5xkN-TrU_1L"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"1. Introduction to Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b><u>1. Introduction to Python</b></u></h3>\n",
    "\n",
    "---\n",
    "Python is an interpreted, high-level, general-purpose programming language. Created by Guido van Rossum and first released in 1991\n",
    "Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is often described as a \"batteries included\" language due to its comprehensive standard library. <br>\n",
    "Python is considered both as a scripting and programming language by most developers as it has support of scripting language as well.\n",
    "The reason for considering it as a \"scripting language\" is because of the ease of coding, automation, deployment and various other reasons. The topic of whether python is a scripting language or just proramming language is hugely debated till now by developers.\n",
    "<br>\n",
    "<br>\n",
    "<u>Keywords to go through in above definition : </u><br>\n",
    "<b>1. Interpreted Language :</b> Interpreted Language specifies that a language can be freely and directly be executed without the need of compiling the code. In case of python, when in *interpreter mode* , one can get the output then and there itself without the need of saving the file and then compiling it. This means even the errors are denoted then and there at that line only and it wll not wait till the completion of the code to tell all the errors in one go. One can go to interpreter by searching for \"python\" in windows search or typing it in cmd or terminal to directly enter it. In case of windows, if the *system environment variables* has been configured properly, you will see the python version and the prompt symbol \">>>\". <br>\n",
    "A <b>\">>>\"</b> (called 'python prompt') specifies an active line waiting for your command, while \"...\" specifies a continued line of code (in case of for loop, if-else, and basically any statements or code that is followed by a colon \":\").<br><br><br>\n",
    "\n",
    "<b>2. Dynamically typed language :</b> Dynamically typed language in layman language means that python doesn't statically limit the coder to one data type for any variable unlike in case of C,C++ or Java. <br><br>&nbsp;<b><u>Eg:</u></b> In case of C or C++ lang, if we declare : \n",
    "\n",
    ">\n",
    "> > #include <stdio.h><br>\n",
    "> > main() <br>\n",
    "> > { <br>\n",
    "> > &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int a; <br>\n",
    "> > &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;a = \"hello\"; <br>\n",
    "> > } \n",
    ">\n",
    "\n",
    "&nbsp;you cannot declare, a = \"hello\" or a = 1.2, as 'a' variable is only int &nbsp;type and it will give error. We can only declare 'a' as a = 79, for example or integer type.\n",
    "<br><br>But in case of python, we directly declare \"value\" and not the \"data-type\" because python by default understands the data-type based on the value you assigned to the variable. This also means you can change the data-type of the variable to any type. This is why python is called \"Dynamically typed\" and not \"statically typed\".\n",
    "<br><br>&nbsp;<b><u>Eg:</u></b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "aPW8ggDb0LA6",
    "outputId": "efd59322-cc98-41b2-c842-1937bc1d246b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Hello world!\n",
      "4.57\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print (a)  #print() function is used to display output in python and is similar to printf(); in C language.\n",
    "\n",
    "a= \"Hello world!\"\n",
    "print (a)\n",
    "\n",
    "a = 4.57\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hJvmjd8-0iiu"
   },
   "source": [
    "(I will be explaining \"print\" and how to declare variables in python in later stages of the notes, though it should be self explanatory for most of you.)<br> Here we can see that the value of variable 'a' is not declared specifically, we just declare the value, say a = 10. We don't say : <br>\n",
    ">\n",
    "> > int a = 10;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//C or C++ example\n",
    ">\n",
    ">\n",
    "\n",
    "We can also observe from the above code snippet that the value of a could be overwritten to any data type. Be it string, integer or float.\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<b>3. Garbage-collected language :</b> Garbage collection (GC) is a form of automatic memory management. The garbage collector, or just collector, attempts to reclaim garbage, or memory occupied by objects that are no longer in use by the program and clears them without need of the programmer to do so on their own.  \n",
    "<br>\n",
    "<br>\n",
    "<b>4. Functional programming language :</b> Functional programming language is most of the time built on Object-oriented programming and allows one to use functions to reduce the need of coding, in their place by using functions. Here these functions are imported using libraries or modules by python which are basically classes which have these functions which act like objects.<br><br> For example, we have functions for string data-type where-in string data-type also acts like a class/module/library and offers functions like lower(), upper(), join(), etc {More about this later}.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ueYSKALK14-m"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"2. Features of Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>2. <u>Features of Python</b></u></h3>\n",
    "\n",
    "---\n",
    "1. Human-friendly code readibility and understanding.\n",
    "2. Easier to code with due to availability of \"Functional-programming\".\n",
    "1. Vast number of libraries and modules that reduce the amount of coding needed to be done drastically.\n",
    "2. Easy to work with in many domains of computer science.\n",
    "1. Can be deployed across various platforms and OS.\n",
    "2. Very simple and easy to learn even for beginners.\n",
    "1. Free and open-source language that is easy to install, set-up and get started with.\n",
    "2. It can be integrated with other languages such as C,C++ and Java. See [Cython](https://cython.org/), [Jython](https://www.jython.org/), etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4HjaQH_3JUzU"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"3. Domain of Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>3. <u>Domain of Python (What is Python used for?)</b></u></h3>\n",
    "\n",
    "---\n",
    "1. Python is used for making desktop applications using GUI programming for various OS like windows, linux, mac, etc. At times the front-end is made using languages like JAVA while back-end is made using python as JAVA is easier to use for making GUI or front-end while python is good for back-end.\n",
    "2. It is used in the trending topics like Machine learning, artificial intelligence and deep learning. This is because any developer can install and import modules/libraries with all the machine learning algorithms already provided in them which can be used as functions (aspect of \"functional prog.\") hence all we need to do is provide the relevant datasets and information and train it by invoking the functions. Python supports all domains of ML, AI and DL like image processing, Natural Language Processing (NLP), chat bots, etc.\n",
    "3. It's used by scientists in scientific researches (like by NASA scientists for space exploration,SUPER Computers, etc).\n",
    "4. It's used for web-developement in back-end using modules like Flask and django.\n",
    "5. It's used in various scripts in hacking and cyber security such as tracking sub-domains of websites, DDOS attacking, etc.\n",
    "6. It's used in data-mining, web scrapping, to download data in back-end in bulk.\n",
    "7. It's used in data-visualization for busiess analytics, etc.\n",
    "8. It's used for automation of various tasks such as automated data-mining or automated sub-domain tracking,etc.\n",
    "9. It's also used rarely for game and mobile app developement.\n",
    "10. It's used in embedded systems like Rasberry pi, etc. for IoT (Internet of Things) products.\n",
    "11. Many other domains like open-source projects, APIs, extensions, plugins construction and deployment, etc.\n",
    "12. It also has applications in cloud computing, blockchain and many buisness enterprises.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-U6nrCgKQ7R1"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"4. Installing and setting-up Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>4. <u>Installing and setting-up Python</b></u></h3>\n",
    "\n",
    "---\n",
    "First things first, make sure that you are sure about your system/laptop configurations. If you are on windows check so on by searching (Win key + s) \"system information\".\n",
    "<br> If you have x64 based system then click on the following -> [link](https://www.python.org/ftp/python/3.7.4/python-3.7.4-amd64.exe).\n",
    "<br> If you have x32 based system then click on the following -> [link](https://www.python.org/ftp/python/3.7.4/python-3.7.4.exe).\n",
    "<br> The links above will download Python 3.7.4 which is the latest as of the time of writing this. (17th Oct, 2019).\n",
    "In case you want to download or check for newer updates you can go to www.python.org and check for the same.\n",
    "\n",
    "While installing make sure <b>\"Add to path\"</b> option is selected so that your python is added to the \"system environment variables\" which basically consists of path to tell the cmd where the applications are stored so that you can use it via your cmd or terminal.<br> \n",
    "<b>(Note : </b> Make sure that you don't have any other versions of python installed when choosing \"Add to Path\" option or there might be clash between the other versions of python which are already installed with this one.)<br><br>\n",
    "After installation of python, open cmd (win key + r, and then type in cmd) and type in python (make sure it's all lowercase).\n",
    "\n",
    "Similarly, I would suggest installing [Sublime Text Editor 3](https://www.sublimetext.com/3) as your editor and try to avoid installing Pycharm and such IDEs as they hamper growth by telling error beforehand hence stopping learning through mistakes and debugging for beginners. You can also set sublime to work from cmd by adding its installation path to environment variables and using the keyterm \"subl\" to run it from cmd.\n",
    "\n",
    "In-case it says \"python not found\" in cmd, follow this [tutorial](https://www.youtube.com/watch?v=Y2q_b4ugPWk) to set-up environment variables.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"5. Python Basic Fundamentals\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>5. <u>Python Basic Fundamentals (Syntax Basics)</b></u></h3>\n",
    "\n",
    "---\n",
    "<a id=\"5A Flow of Code\"></a>\n",
    "<br><b>(a.)Flow of Code </b><br>\n",
    "Just like how we read books from top to bottom and left to right, the flow of the code works in the same way usually in python as well (Just like how it's done in C, C++ or Java). The [python interpreter]() reads the code from the 1st line to the last line provided there aren't any jump statements like function calls or decision/conditional statements or looping statements that would make a piece of code loop again and again until a specific condition is met. This is important to keep in mind as we have to make sure the right line of code is being executed at the right time or else we won't get the desired results. \n",
    "\n",
    "<a id=\"5B Semi-colons in Python\"></a>\n",
    "<br><b>(b.) Semi-colons in Python </b><br>\n",
    "Unlike C, C++ languages, Python doesn't require a semi-colon (;) to end a line of code. The python interpreter itself understands a new line as end of that line of code. Even though semi-colon isn't required, python still supports usage of semi-colon and is used the same way as in C & C++. It can be used to write two lines of code in one by using a semi-colon\n",
    "to end them. Since, python reads the code from left to right as mentioned above, the left-most statement will be considered first then the ones following it after the semi-colon. Eg:<br>\n",
    "<code>a = 1; b = 2;</code><br>\n",
    "and\n",
    "<code>\n",
    "a = 1\n",
    "b = 2</code><br>\n",
    "Both are valid in python.\n",
    "<br>\n",
    "\n",
    "<a id=\"5C Indentation in Python\"></a>\n",
    "<br><b>(c.) Indentation in Python </b><br>\n",
    "Another thing to keep in python is that unlike C & C++ which use Curly Braces {} to refer to a block of code belonging to\n",
    "a conditional or loop statement (if-else, for or while loop), Python uses <b>Indentation</b> to indicate which block of code is under a conditional or loop statement. Since explaining in text is not easy, I would suggest [watching this](https://www.youtube.com/watch?v=igFtmXV_9vE) short video to get a clearer idea, with further examples in loopa and conditional statements below it will become clearer what indentation is.\n",
    "\n",
    "      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AvRgjwfUHYKX"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"6. Commenting in Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>6. <u>Commenting in Python</b></u></h3>\n",
    "\n",
    "---\n",
    "\n",
    "Comments are used for adding personal instructions or lines that the compiler or interpreter ignores. This allows the developer to add lines to further explain his/her code to other developers who might go through your code later or even allow the creator to remember what a specific region of code did.\n",
    "\n",
    "<h4><u><b>Why commenting is important : </u></b></h4>\n",
    "<li> Sometimes you have projects spanning with over 100 to thousands of lines of codes. One person can't possibly remember what a specific region of code does in thousands line of codes and hence adding comments allows one to understand the context of the code.</li>\n",
    "<li> It's a crucial part of documentation and is evident in many open source projects, etc that you will find online.</li>\n",
    "<li> It allows other coders going through your code to understand your code better as everyone has different coding style. It's important if you are working on a project with a team.</li>\n",
    "<br>\n",
    "The best code practice is when your code is readiable from the get go though, without the need of explaining.\n",
    "<br><br>\n",
    "<b>NOTE : </b> Since this is a tutorial kind of book, I will be using a lot of comments through the code, kindly keep keen eye for them as I will be explaining in much more detail with them.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FSgGR4MLGsag"
   },
   "source": [
    "<a id=\"6A Single line commenting in Python\"></a>\n",
    "<u><b> (a.) Single-line commenting in Python: </b></u><br>\n",
    "We use Hash<code>(#)</code> symbol while commenting in single line in python. This is handy if we want to comment a specific line of the code to disable it and see how the output of the code works. Eg : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "RTj1x_bKVycX",
    "outputId": "70bdea20-5acf-4e70-f44b-7acb37d70347",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This statement will get printed\n",
      "Value of a is :  2\n"
     ]
    }
   ],
   "source": [
    "#Example of single line commenting in python\n",
    "\n",
    "a = 2\n",
    "b = 4\n",
    "print (\"This statement will get printed\")  #This statement won't be displayed or get printed as it is a comment\n",
    "print (\"Value of a is : \",a)\n",
    "#print (b) \n",
    "#the above line is a comment just as this line. Try uncommenting by removing the hash (#) before print (b) statement.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "225O33LkW-6z"
   },
   "source": [
    "<a id=\"6B Multi-line commenting in Python\"></a>\n",
    "<br><br><b><u>(b.) Multi-line commenting in python</u> : </b>\n",
    "<br>Mutli-line commenting means commenting multiple lines in one go. This is useful when you want to comment out a whole specific block of codes (multiple code statements) unlike just one or two statements. For example you can comment out a whole for-loop if you think it's causing errors in your code and see if your code works with it or without it.<br><br>\n",
    "You can do multi-line commenting in python using triple quotes <code>\"\"\".</code>. These triple-quotes are actually unlike # (single comments) not ignored by the python interpreter because, they aren't comments (which the interpreter ignores) but the string data-type. Tripe-quotes basically are multi-line strings which if not assigned to a variable or used in print() function converts the whole code-block to a string which isn't outputted anywhere. So this code-block acts as a commented block but in traditional sense it is not comments but string datatype. To get started, just type everything inside the triple quotes and enclose it by them.<br>\n",
    "<a href=\"#8C Multi-line printing in Python\">More on Multi-line printing.</a>\n",
    "<br>\n",
    "<br>\n",
    "Eg : \n",
    "  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "WOReqTRHVMvM",
    "outputId": "ad602f42-ab01-47e8-92b0-8cd7204b60e1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is not a comment\n"
     ]
    }
   ],
   "source": [
    "#Example of Multi-line commenting in python\n",
    "\n",
    "#This is a single line comment using hash (#)\n",
    "\"\"\"\n",
    "Look this is the first line.\n",
    "The second line.\n",
    "The third line.\n",
    "And all these lines are comments. The below code won't be executed : \n",
    "a = 2\n",
    "print (a)\n",
    "\"\"\"\n",
    "\n",
    "print (\"This is not a comment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"7 Variables & Variable Assignment in Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>7. <u>Variables & Variable Assignment in Python</b></u></h3>\n",
    "\n",
    "---\n",
    "Variables are used to assign\n",
    "<b><h4>Variable names :</h4></b>\n",
    "Couple of rules to follow when naming your variables \n",
    "<ul>\n",
    "<li>Variable names can contain letters, numbers, and the underscore.</li>\n",
    "<li>Variable names cannot contain spaces.</li>\n",
    "<li>Variable names cannot start with a number or contain any other symbols besides underscore.</li>\n",
    "<li>Case matters—for instance, temp and Temp are different.</li>\n",
    "<li>Since python is dynamically typed, declaring data-type with variables isn't required </li>\n",
    "</ul><br><b>Eg : </b><br>\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1   #Notice how we don't need to declare data-types for variables like in C & C++ due to dynamic-typing\n",
    "        #as mentioned above Python automatically detemines variable, 'a' holding an int value.\n",
    "b = \"hello\"  #Python automatically determines variable 'b' holding a string value\n",
    "c = 4.2      #Python automatically determines varaible 'c' holding a float value\n",
    "\n",
    "#We can also assign values in various other ways like :\n",
    "a = 1; b = \"hello\"; c = 4.2;   #One line assignment using semi-colons\n",
    "\n",
    "#We can also use another method for assigning values to variables :\n",
    "a,b,c = 1,\"hello\",4.2  #This method unpacks the int value 1 to variable 'a' as both are on extreme left\n",
    "                       #string value \"hello\" is assigned to variable 'b' as both are in middle\n",
    "                       #float value 1.2 is asssigned to variable 'c' as both are on extreme right\n",
    "        \n",
    "#Even though we have assigned values to variables 'a', 'b' and 'c', we cannot display them or use them without\n",
    "#printing or getting an output for them. This can be done using the print() function in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"8 Print function in Python\"></a>\n",
    "\n",
    "---\n",
    "<h3> <b>8. <u>Print function in Python</b></u></h3>\n",
    "\n",
    "---\n",
    "<code>print()</code> function is similar to <code>printf();</code> function in C & C++. But unlike C & C++ it doesn't need necessarily need a type specifier (%d, %s, %f) etc to print values of variables. You can directly print the value or the variable holding the value without using the type-specifier for the data-type that value belongs to. In python 2.7, print was a [keyword](https://www.programiz.com/python-programming/keywords-identifier#:~:text=Keywords%20are%20the%20reserved%20words,33%20keywords%20in%20Python%203.7.) and hence did not require any paranthesis or brackets () after it, but from Python 3, print() is a function and hence it requires paranthesis which in which we pass the values or variables we want to print the output of.\n",
    "<br>\n",
    "<a id=\"8A Single-line printing in Python\"></a>\n",
    "<b>(a.) Single line printing in Python</b><br>\n",
    "Eg : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a single line print \n",
      "The value of a is\n",
      "The value of a is :  1\n",
      "The value of b is :  hello\n",
      "The value of c is :  4.2\n"
     ]
    }
   ],
   "source": [
    "print (\"This is a single line print \")\n",
    "a,b,c = 1,\"hello\",4.2\n",
    "\n",
    "#We use commas to seperate the values we want to print, below we are telling python to \n",
    "#print the string value \"The value of a is\" followed by a comma to tell python the next value we want to print\n",
    "#after the string value \"The value of a is\" and after the comma we mention the variable \"a\" to make python\n",
    "#Print it's value.\n",
    "\n",
    "print (\"The value of a is\")        #Value of variable 'a' won't be printed as we haven't mentioned it here\n",
    "print (\"The value of a is : \",a)   #Notice how we don't need to necessarily use type-specifier %d to print value of var a.\n",
    "print (\"The value of b is : \",b)   #%s isn't necessarily required for printing value of b.\n",
    "print (\"The value of c is : \",c)   #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>\n",
    "<a id=\"8B Escape sequence in Python\"></a>\n",
    "<b>(b.) Escape Sequence in Python</b><br>The above statements are printed just fine but I feel like there is little too less gap between each print statement.\n",
    "We can add empty new lines , empty tab spaces, etc using [\"escape sequence or escape character\"](http://www.python-ds.com/python-3-escape-sequences) to make our output more pretty.<br>\n",
    "<b>\"\\n\"</b> and <b>\"\\t\"</b> are the two most commonly used escape sequences and are used in many other programming languages like C,C++,Java, etc.<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<li><b>\\n</b> : It is used to print an empty new line. Usually used to add spaces between two print statements.</li>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<li><b>\\t</b> : It is used to print an empty tab space (Usually 4 to 8 combined spaces) before or after a statement.</li><br> \n",
    "<b>Eg: </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "The values of variables 'a','b' and 'c' are : \n",
      "\n",
      "\tThe value of a is :  1 \n",
      "\n",
      "\tThe value of b is :  hello\n",
      "\n",
      "\tThe value of c is :  4.2\n"
     ]
    }
   ],
   "source": [
    "print (\"\\n\\nThe values of variables 'a','b' and 'c' are : \")\n",
    "print (\"\\n\\tThe value of a is : \",a,\"\\n\")  #You can add \\n at end as well to create the next new line \n",
    "print (\"\\tThe value of b is : \",b)   \n",
    "print (\"\\n\\tThe value of c is : \",c)       #Here the new line has been added in beginning instead of last of previous\n",
    "                                           #print statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id=\"8C Multi-line printing in Python\"></a>\n",
    "<b>(c.) Multi-line printing in Python</b> :<br>\n",
    "We use <code>\"\"\"</code> triple quotes just like in case of multi-line in commenting (Topic 5 in contents) comments for multi-line printing. See the following examples below :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " This is a sentence. This is a second sentence!\n",
      " The third sentence. This sentence is fourth.\n",
      " Fifth sentence is this one. \n",
      " \n",
      "What's up my friend?\n",
      "Nothing much dude, just chilling you know\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"What's up my friend?\\nNothing much dude, just chilling you know\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Multi-line printing in python\n",
    "\n",
    "print (\"\"\"\n",
    " This is a sentence. This is a second sentence!\n",
    " The third sentence. This sentence is fourth.\n",
    " Fifth sentence is this one. \n",
    " \"\"\"\n",
    ")\n",
    "\n",
    "st = \"\"\"What's up my friend?\n",
    "Nothing much dude, just chilling you know\"\"\"    #Assigning multi-line strings to a variable\n",
    "\n",
    "print (st)\n",
    "\n",
    "#see how escape sequence \\n is added wherever the line breaks, which isn't visible when we use print() function\n",
    "# (there's a \\n before 'Nothing' in st variable)\n",
    "st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\t\n",
      "\n",
      "___________________________________ \n",
      "< I am an ASCII Art Dragon > \n",
      " ----------------------------------- \n",
      "      \\                    / \\  //\\ \n",
      "       \\    |\\___/|      /   \\//  \\ \n",
      "            /0  0  \\__  /    //  | \\ \\     \n",
      "           /     /  \\/_/    //   |  \\  \\   \n",
      "           @_^_@'/   \\/_   //    |   \\   \\  \n",
      "           //_^_/     \\/_ //     |    \\    \\ \n",
      "        ( //) |        \\///      |     \\     \\ \n",
      "      ( / /) _|_ /   )  //       |      \\     _\\ \n",
      "    ( // /) '/,_ _ _/  ( ; -.    |    _ _\\.-~        .-~~~^-. \n",
      "  (( / / )) ,-{        _      `-.|.-~-.           .~         `. \n",
      " (( // / ))  '/\\      /                 ~-. _ .-~      .-~^-.  \\ \n",
      " (( /// ))      `.   {            }                   /      \\  \\ \n",
      "  (( / ))     .----~-.\\        \\-'                 .~         \\  `. \\^-. \n",
      "             ///.----..>        \\             _ -~             `.  ^-`  ^-_ \n",
      "               ///-._ _ _ _ _ _ _}^ - - - - ~                     ~-- ,.-~ \n",
      "                                                                  /.-~ \n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Multi-line printing in python (Example 2)\n",
    "\n",
    "print (\"\"\"\n",
    "\t\\n\n",
    "___________________________________ \n",
    "< I am an ASCII Art Dragon > \n",
    " ----------------------------------- \n",
    "      \\                    / \\  //\\ \n",
    "       \\    |\\___/|      /   \\//  \\\\ \n",
    "            /0  0  \\__  /    //  | \\ \\     \n",
    "           /     /  \\/_/    //   |  \\  \\   \n",
    "           @_^_@'/   \\/_   //    |   \\   \\  \n",
    "           //_^_/     \\/_ //     |    \\    \\ \n",
    "        ( //) |        \\///      |     \\     \\ \n",
    "      ( / /) _|_ /   )  //       |      \\     _\\ \n",
    "    ( // /) '/,_ _ _/  ( ; -.    |    _ _\\.-~        .-~~~^-. \n",
    "  (( / / )) ,-{        _      `-.|.-~-.           .~         `. \n",
    " (( // / ))  '/\\      /                 ~-. _ .-~      .-~^-.  \\ \n",
    " (( /// ))      `.   {            }                   /      \\  \\ \n",
    "  (( / ))     .----~-.\\        \\-'                 .~         \\  `. \\^-. \n",
    "             ///.----..>        \\             _ -~             `.  ^-`  ^-_ \n",
    "               ///-._ _ _ _ _ _ _}^ - - - - ~                     ~-- ,.-~ \n",
    "                                                                  /.-~ \n",
    "\\n\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IdIhEfrziZRf"
   },
   "source": [
    "<br>\n",
    "<br>\n",
    "<a id=\"9 Primary data types in Python\"></a>\n",
    "\n",
    "---\n",
    "<h3><b>9. <u>Primary Data-types in Python</b></u></h3>\n",
    "\n",
    "---\n",
    "There are two types of data-types in python in layman terms. \n",
    "1. Primary Data type\n",
    "2. Secondary Data type or Container Data type\n",
    "\n",
    "<b>Primary Data type :</b> <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "It consists of the following data types :\n",
    "* Int or Integer (Denoted by %d as a placeholder)\n",
    "* Float or decimal numbers (Denoted by %f as  a placeholder)\n",
    "* String (Denoted by %s as a placeholder)\n",
    "* None data type\n",
    "* Boolean data type (Denoted by True/1 or False/0 as reserved keywords)\n",
    "* Complex Numbers <br>\n",
    "<br>\n",
    "\n",
    "<b>Secondary Data type :</b>\n",
    "It contains primary data types (the ones mentioned above) as it's elements or values, basically they are container data types that consist of various primary data type values stored in them which allows us to store multiple values of any data type and assign to just one variable. This reduces of stating multiple variables for similar values.\n",
    "* Lists (Arrays variation of C and C++ Lang for python)\n",
    "* Tuples (Basically immutable python lists)\n",
    "* Sets\n",
    "* Dictionaries (Comsists of keys mapped to values, unordered (don't follow any order such as index, keys&Values can be in any order)\n",
    "* Collections (ordered dictionaries)\n",
    "* Numpy, etc (Numerical arrays for scientific and machine learning projects)\n",
    "\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; All these data types have unlimited memory allocation (which implies it depends on one's PC memory limits, this also means you don't need to assign size of array, string, etc like in case of C/C++ as python has unlimited memory allocation and also automated garbage collector which works hand in hand with dynamic typing.) Unlike in C/C++ where you initialize strings as : <br>\n",
    "> char a[10];\n",
    "\n",
    "<br>You can just declare,<br>\n",
    "<code>a = \"hello\"</code> or <br><code>a = \"This sentence can be as long as you want without the need of declaring the number of characters in it, really you can stretch it as long as you want it to.\"</code>\n",
    "<br><br>\n",
    "Here all the data types except int and float are also treated classes/modules/libraries because int and float data types are only meant to be used for mathematical operations like addtion, subraction, etc.\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xz_9b07UDVoP"
   },
   "source": [
    "<hr><br>\n",
    "<a id=\"9A Integer data type\"></a>\n",
    "<h3><u><b>(a.) Integer Data-Type (int)</b></u></h3><br>\n",
    "<u><b>Declaring int value :</b></u><br>\n",
    "We use '=' as the assignment operator which assigns values to the variable.<br> \n",
    "<code>a = 1<br>\n",
    "b = 2<br>\n",
    "a = 1; b = 2<br>\n",
    "a, b = 1, 2 <br></code>All work. Here 'a' & 'b' are variables holding the values 1 and 2 throughout the whole example. You can use semi-colons like in C/C++ to seperate variables and statements but I wouldn't suggest to use them everywhere also keep in mind, if you do a,b = 1,2,3 you will get error as python expects at least 3 variables in this case, so you would have to do a,b,c = 1,2,3.<br><br><b>Note :</b> By the way, these declaration methods work for float, strings, and all other various data types. <br>\n",
    "<br><u><i>Working with integers :</i></u><br>\n",
    "Before working with integers you need to know what are operators and their uses. You must have used them in maths before (if you haven't, what are you doing in your life anyway :v)\n",
    "\n",
    "<br>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1gCnhTNqEQvt"
   },
   "source": [
    "\n",
    "<b> Operators in python :</b>\n",
    "<ul><li> Addtion (+) </li>\n",
    "<li> Subraction (-) </li>\n",
    "<li> Multiplication (<b>*</b>) </li>\n",
    "<li> Division (/) {Gives float value as quotient} </li>\n",
    "<li> Double Division (//) {Gives int value as quotient} </li>\n",
    "<li> Modulus (%) {Returns remainder} </li>\n",
    "<li> Exponential (<b>**</b>) {Returns the raised to power of a number} </li></ul<\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Rijc102SEHp0"
   },
   "source": [
    "<hr><br>\n",
    "<a id=\"9A i. Addition\"></a>\n",
    "<br><br><u><b>i.) Addition operator : '+'</b></u>\n",
    "(Adds two or more numbers)<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 1; b = 2; c = a+b+2\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (c)\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#(Answer will be 5)\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> c + = 1 \n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (c)\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#(Answer will be 6 now)\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;c + = 1 is equaivalent to c = c + 1 (since c = a+b+2 was equal to c = 5, c + = 1 implies,<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;c = c + 1, which in turn implies, c = 5 + 1, c = 6)\n",
    "<br>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Note :** In python pre-increment or post-increment like in case of C/C++ doesn't exist, therefore we cannot use a++ or ++a, but we can use a+=1.\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "NktDS2b8bJcE",
    "outputId": "15a5efac-99b4-4317-81ee-d8ec9ae39ee8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial value of c :  5\n",
      "Updated value of c :  6\n",
      "The new updated value of c is :  8\n"
     ]
    }
   ],
   "source": [
    "#Addtion Example (+)\n",
    "\n",
    "a = 1; b = 2; c = a+b+2\n",
    "print (\"Initial value of c : \",c)\n",
    "c+=1\n",
    "print (\"Updated value of c : \",c)\n",
    "c+= 2\n",
    "print (\"The new updated value of c is : \",c) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Clr7iBCba-aS"
   },
   "source": [
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br>\n",
    "<a id=\"9B ii. Subraction\"></a>\n",
    "<u><br><br> <b>ii.) Subraction Operator : '-'</b></u> \n",
    "(Subracts two or more numbers)</u>\n",
    "<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 5; b = 7; b - = 1; a = a - b;\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (a)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is -1)<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; As b - = 1 => b = 7 - 1 => 6, and then a = a - b => a = 5 - 6 = -1<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; orrrrrrrr <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; just do the maths bruh.\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "NnBcaGtCl6TU",
    "outputId": "8d7d19ea-fc76-41c9-8c74-2e892d645015"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is :  -1\n"
     ]
    }
   ],
   "source": [
    "#Subraction (-)\n",
    "a, b = 5, 7   #Here a=5,b=7\n",
    "b-=1  \n",
    "\"\"\"Sometimes, running the same command such as : b - = 1 (just added spaces in the same statement) causes errors. \n",
    "So we cannot use spaces everywhere.\"\"\"\n",
    "a = a - b;\n",
    "print (\"The value of a is : \",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lucm3D11m7G5"
   },
   "source": [
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br>\n",
    "<a id=\"9A iii. Multiplication\"></a>\n",
    "<b><u>iii.) Mutiplication Operator : '(\\*)'</b></u> (Mutliplies two or more numbers)\n",
    "<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 5; b = 7;  c = a * b;\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (c)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is 35)\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "OeDYUrLVnAsg",
    "outputId": "649997de-9493-4021-ae12-6e971a198724"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "#Multiplication (*)\n",
    "a = 5; b = 7; c = a * b;\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e66zu3IunBL7"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b>\n",
    "<a id=\"9A iv. Division\"></a>\n",
    "<br><br><b><u>iv.) Division Operator : '/'</b></u>\n",
    " (Divides two or more numbers)\n",
    "<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>Eg : >>> a = 15 ; b = 5 ;  c = 2 ; d = 150 ; e = a/b ; f = a/c ; g = a/d</code>\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (e,\" and \",f,\" and \",g)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is 3.0 and 7.5 and 0.1)\n",
    "<br>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Note :** Notice how the output is 3.0 and not 3, this shows just using a single / returns float value as quotient even if the output is completely divisible like in case of 15/5. Also notice how 15/150 is 0.1\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "dvsxveI1nYrD",
    "outputId": "70e234ad-6658-441a-b490-a9f5d7e81d1d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of e is : 3.0 ,and of f is : 7.5 ,while of g is : 0.1\n"
     ]
    }
   ],
   "source": [
    "#Division (/)\n",
    "a = 15; \n",
    "b = 5  \n",
    "c = 2  \n",
    "d = 150  \n",
    "e = a/b; \n",
    "f = a/c ; \n",
    "g = a/d\n",
    "print (\"Value of e is :\",e,\",and of f is :\",f,\",while of g is :\",g) \n",
    "#Compare this to output of below code block of double division operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vOT3zffanZRI"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br><br>\n",
    "<a id=\"9A v. Double Division\"></a>\n",
    "<u><b>v.) Double division Operator : '//'</b></u>\n",
    " (Divides two or more numbers but returns integer quotient instead of a float quotient)\n",
    "<br></u> <br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 15; b = 5;   c = 2; d = 150; e = a//b; f = a//c; g = a//d\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (e,\" and \",f,\" and \",g)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is 3 and 7 and 0)\n",
    "<br>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Note :** Notice how the output is 3 and not 3.0, this shows the output while using // is always int. We can observe the same for 15//2 which returns 7 and doesn't return the correct answer which is 7.5, hence it will ignore any value past decimal as in case of 15//150 which just returns 0 as quotient.\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "xQbN7gRhoG7h",
    "outputId": "c430525c-36c6-406f-8c61-2329f6e7eaa4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of e is : 3 ,and of f is : 7 ,while of g is : 0\n"
     ]
    }
   ],
   "source": [
    "#Double-division (//)\n",
    "a = 15; b = 5; \n",
    "c = 2; d = 150\n",
    "e = a//b; \n",
    "f = a//c; \n",
    "g = a//d\n",
    "print (\"Value of e is :\",e,\",and of f is :\",f,\",while of g is :\",g) \n",
    "#Compare this to above code block output of division operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hw02DYc-oIjt"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b>\n",
    "<a id=\"9A vi. Modulus\"></a>\n",
    "<br><br><u><b>vi.) Modulus Operator : '%'</u></b>\n",
    " (Returns remainder)\n",
    "<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 15; b = 5;   c = 2; d = a%b; e=a%c\n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (d,\" and \",e)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is 0 and 1, as the remainder for 15//5 is 0 and for 15//2 is 1)\n",
    "<br>\n",
    "<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "h0C27k3qp4FA",
    "outputId": "fbf572fe-8b5f-450e-ec58-dadd38d31668"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of d is : 0 \n",
      "and value of e is: 1\n"
     ]
    }
   ],
   "source": [
    "#Modulus (%)\n",
    "a = 15; b = 5; c = 2; \n",
    "d = a%b; e=a%c\n",
    "print (\"Value of d is :\",d,\"\\nand value of e is:\",e)   \n",
    "#\\n is used to print to new line. \\n is called an escape squence, \n",
    "#it is a special charater reserved in many coding languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OWus9QPVp4kn"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b>\n",
    "<a id=\"9A vii. Exponential\"></a>\n",
    "<br><br><u><b>vii.) Exponential Operator : (\\*\\*)</b></u>(Raises two numbers)\n",
    "<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Eg : >>> a = 4; b = 4;   \n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;>>> print (a<b>**</b>2,\" and \", a<b>**</b>b, \" and \", a<b>**</b>0.5)\n",
    "<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(Answer is 16 and 256 and 2.0)\n",
    "<br>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Note :** 4^2 or 4 to the power 2 or 4 raised to 2 is 16 (4x4=16), 4^4 is 256 (4x4x4x4=256) and 4^0.5 is (4)^1/2 which basically means underoot of 4. Notice that the output is 2.0 for 4^0.5 not 2, as we are using 0.5 which is a float value so we get a float output. Similarly, if we did \n",
    "4^2.0 instead of 4^2 we would get 16.0 not 16. This is true for all operators, integer and operator and float = float ouptput. Eg : 4<b>*</b>2.0=8.0 (Here, ^ denotes <b> ** </b> operator)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "ZovzEoV5qQ4i",
    "outputId": "862a1e18-1d21-48af-85f0-ffb27fd31f6f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'a' raised to power of 2 is: 16 \n",
      "and 'a' raised to power of b is : 256 \n",
      "and 'a' raised to 0.5 is: 2.0\n"
     ]
    }
   ],
   "source": [
    "#Exponential (**)\n",
    "a = 4; b = 4;\n",
    "print (\"\\'a\\' raised to power of 2 is:\",a**2,\"\\nand \\'a\\' raised to power of b is :\", a**b, \"\\nand \\'a\\' raised to 0.5 is:\", a**0.5)\n",
    "\n",
    "#\\' \\' Is used to treat single quotes here as raw string, meaning as string itself, as using them without slash (\\) would make python think\n",
    "#that we are using it to encapsulate a string (basically single quotes are also used to print and assign string value, so to not use them for\n",
    "#declaration but for printing purposes we use the slash (\\))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HASM5DqaqReS"
   },
   "source": [
    "<br><br><hr><br>\n",
    "<a id=\"9B Float data type\"></a>\n",
    "<h3><u><b>(b.) Float Data type (float)</b></u></h3><br>\n",
    "<u><b>Declaring float value :</b></u><br>\n",
    "We use '=' as the assignment operator which assigns values to the variable.<br> \n",
    "a = 1.2<br>\n",
    "b = 2.5<br>\n",
    "a = 1.2; b = 2.5<br>\n",
    "a,b = 1.2,2.5 <br>All work. Here 'a' & 'b' are variables holding the values 1.2 and 2.5 through the whole example. Basically it's the same as declaring int or string  values.\n",
    "<br><br><u><b>Working with floats :</b></u><br>\n",
    "It's the same as integer values in python (I mean floats are just integers in the end but they have a point, so obviously it works just the same). Operators like addition, subraction, multiplication, division, modulus, all the operators mentioned above work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "Jw_30XDUrmn8",
    "outputId": "090f871a-0760-475f-abcf-7ec2e13bb81e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of 'a' and 'b' is : 5.04\n"
     ]
    }
   ],
   "source": [
    "#Float data type\n",
    "\n",
    "#Try using operators with float values like the above examples here. I have done one for you\n",
    "\n",
    "a= 1.2 #spaces between variable and = (assignment operator) does not matter.\n",
    "b =4.2\n",
    "#though it is a good idea to practise standard spacing like in above examples, like this : a = 1.2\n",
    "print (\"The product of \\'a\\' and \\'b\\' is :\",a*b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TFwiAmWWsmLz"
   },
   "source": [
    "<br><br><hr><br>\n",
    "<a id=\"9C String data type\"></a>\n",
    "<h3><u><b>(c.) String Data type (str)</b></u></h3><br>\n",
    "<br>\n",
    "Unlike int and float values which can only be used for maths and with operators, we can do a lot with strings, like : concatenation of strings, reversing a string, slicing strings, capitalizing them, etc and hence python treats string not just like a datatype but as a module/library  also, meaning it has it's own sets of functions that can be used with strings.\n",
    "This allows us coders to just call the function instead of typing multiple lines of codes to do the same thing. This is a feature of python as it's also a functional programming language as I mentioned in the features section of python. (2nd topic in Content).\n",
    "<br><br>\n",
    "String datatype consists of all alphabets letters, symbols, signs and alphanumeric values. They are represented inside quotes (\"\").\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G6nzuVjxHNpC"
   },
   "source": [
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br>\n",
    "<a id=\"9C i. Declaring string values\"></a>\n",
    "<br><u><b>(i.) Declaring String Values</b></u> :<br>\n",
    "<code>var = \"hello potato\"</code> #You can make this sentence as long as you like <br>\n",
    "<code>print (var)<br><br>\n",
    "var1 = \"hello potato this is a longer sentence which can stretch for many virtual kilometers provided you have the patience to type that much\"\n",
    "<br>\n",
    "print (var1)</code><br><br>\n",
    "Eg :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "i6hC7_lO2O1a",
    "outputId": "7498ee98-cb63-4ad2-fb97-5225a8db7548"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello potato\n",
      "hello potato this is a longer sentence which can stretch for many virtual kilometers provided you have the patience to type that much!\n"
     ]
    }
   ],
   "source": [
    "#Declaring strings in python\n",
    "\n",
    "var = \"hello potato\"  #Pretty self explanatory and I have explained the same in the beginning of introduction about Datatypes in python\n",
    "#topic 6 in contents\n",
    "print (var)\n",
    "var1 = \"hello potato this is a longer sentence which can stretch for many virtual kilometers provided you have the patience to type that much!\" \n",
    "print (var1)  #No need to do : char var1[100] like in case of c/c++, it's technically unlimited memory allocation by default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ooS82LbN4V78"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br>\n",
    "<a id=\"9C ii. String concatenation in python\"></a>\n",
    "<br><b><u>(ii.) String concatenation in Python :</u></b><br>\n",
    "String concatenation refers to the act of joining two strings together to make a new string consisting both the previous strings. Like this multiple strings can be joined together. String concatenation is very simple in python. You just add text as it is. Following example below will demonstrate everything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "K6Pd6BRf5FQd",
    "outputId": "541d7c16-d7c8-4a2b-bcbc-7d84a95fa148"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello potato \n",
      "hello potato hello potato \n",
      "hello potato hello potato !!\n",
      "\n",
      "Mic testing 123 Mic testing 123 !! hello potato , can you hear me now ?\n"
     ]
    }
   ],
   "source": [
    "#Example of string concatenation in python\n",
    "\n",
    "a = \"hello\"\n",
    "b = \" \"  #empty space\n",
    "c = \"potato\"\n",
    "d = a+b+c+b #string concatenation\n",
    "print (d)\n",
    "print (d+d+\"\\n\"+d+d+\"!!\")  #another example of string concatenation\n",
    "\n",
    "e = \"123\" #Notice how variable 'e' is holding 123 as a string value, not as an integer. We can clearly notice this using the \"\" (Double quotes)\n",
    "#around 123. We cannot do string concatenation for integer and string. String conct. is only possible for strings.\n",
    "f = \"Mic testing\"\n",
    "print (\"\\n\"+f+b+e+b+f+b+e+\" !!\"+\" \"+d+\",\",\"can you hear me now ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pN_1Dw3l6dfd"
   },
   "source": [
    "\n",
    "<b>----------------------------------------------------------------------------------------------------------------------------------------------</b><br>\n",
    "<a id=\"9C iii. Indexing and slicing strings\"></a>\n",
    "<br><b><u>(iii.) Indexing and slicing strings in Python :</u></b><br>\n",
    "<ul><li> <u>Definition of Index/Indices</u></li><ul> :\n",
    "<br>It is a common method for keeping track of data so that it can be accessed quickly. Like an index in a book, it is a numeric value in which each entry contains the name of the item or element and its location. However, computer-based indexes may point to a physical location on a disk or to a logical location that points elsewhere to the actual location.<br>\n",
    "Indices (plural of 'index') start from 0 (zero) and go on to n-1, where 'n' is the number of characters in the string in this case. For eg: the string \"hello\" has n = 5 value as \"hello\" has 5 characters, hence the indices will start from 0 and go on till n-1, i.e, 5 - 1 = 4.<br>\n",
    "In python, indexing is represented as follows, say : a = \"hello\"; then a[index_number] is the syntax of using indices for string (as well as lists which will be explained later). So in this case, a[0], a[1], a[2], a[3] and a[4] are indices of the variable 'a'. Each of these indices, hold a character of that string assigned to the variable. Therefore, for a = \"hello\", a[0]=>'h', a[1]=>'e',a[2]=>'l', a[3]=>'l', a[4]=>'o'. We don't have a[5] as the length of \"hello\" is 5, and indices range from 0 to n-1 as I said before, so here it is 0 to 4 indices. Similar example : b = \"Name\", here indices of 'b' from 0 to 3 where, b[0]='N', b[1]='a', b[2]='m' and b[3]='e'. <br><br>\n",
    "Unlike in C/C++, Python also has negative indices as well, meaning if a = \"hello\", then it will have that many negative indices as well, meaning, indices from -1 to -5 (as \"hello\" has 5 letters in it), but notice that the positive indices are start from 0 to n-1, or 5-1=4 (0 to 4 in case of \"hello\"). So negative indices are represented in the following way : a[-5], a[-4], a[-3], a[-2] and a[-1].\n",
    "<br> So what's the difference between positive indices and negative indices you may think?\n",
    "<br> Negative indices return characters from the other end or the right-end. This is useful when you got to print values from the other end of the string or don't exactly know what the last character of the string is. Eg : a=\"hello\"; then a[-5]=>\"h\",a[-4]=>\"e\",a[-3]=>\"l\",a[-2]=>\"l\",a[-1]=>\"o\".<br>\n",
    "So from the above you can understand that :<br>\n",
    "<br> a[0] => a[-5] => \"h\";\n",
    "<br> a[1] => a[-4] => \"e\";\n",
    "<br> a[2] => a[-3] => \"l\";\n",
    "<br> a[3] => a[-2] => \"l\";\n",
    "<br> a[4] => a[-1] => \"o\";\n",
    "<br><br> So the following indices hold the same value and can be used as per our likings or situation. Sometimes it's easier to use the negative indices while sometimes it's easier to use the positive indices (like in most cases) or in some cases it's easier to use both.\n",
    "<br> <br>NOTE : I am using \"=>\" instead of \"=\" for a[0]=>\"h\" because \"=\" (equal to) is an assignment operator and will show error if you use a[0]=\"h\" in our case, I am just trying to make you understand that a[0] holds the value \"h\" and this can only be presented using : print(a[0]).\n",
    "<br>\n",
    "<br> EG:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 223
    },
    "colab_type": "code",
    "id": "G8oBET8z_4Em",
    "outputId": "b766e71b-f840-4c13-b01a-508c29e1770f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  a\n",
      "  p e\n",
      "  p  l\n",
      "  l   p\n",
      "  e    p\n",
      "--------- apple\n",
      "  e    p\n",
      "  l   p\n",
      "  p  l\n",
      "  p e\n",
      "  a\n"
     ]
    }
   ],
   "source": [
    "#Example of indices in strings\n",
    "a = \"apple\"\n",
    "print (\" \",a[0])                #Positive indices from 0 to 4 (coz \"apple\" has 5 characters so, it's from 0 to n-1, or 5-1 = 4)\n",
    "print (\" \",a[1],a[4])\n",
    "print (\" \",a[2],\"\",a[3])\n",
    "print (\" \",a[3],\" \",a[2])\n",
    "print (\" \",a[4],\"  \",a[1])\n",
    "print (\"---------\",a)\n",
    "print (\" \",a[-1],\"  \",a[-4])    #Negative indices from -1 to -5 (coz \"apple\" has 5 characters)\n",
    "print (\" \",a[-2],\" \",a[-3])\n",
    "print (\" \",a[-3],\"\",a[-2])\n",
    "print (\" \",a[-4],a[-1])\n",
    "print (\" \",a[-5])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6JyZqLbXHPcl"
   },
   "source": [
    "<ul><li><u>Slices in strings </u></li></ul> :\n",
    "<Br> So uptil now we have learned about indices in strings. Now moving to the next topic, which is slices. It uses the concept of indices to work. If you remember correctly, if a=\"apple\", then a[0]=>\"a\". Here, we are just using one index, i.e., 0 (zero). But in actual, we can input upto three parameters inside the [ ] (square brackets).\n",
    "<br>The important thing to remember is this :\n",
    " <ul><li> We can input upto three parameters inside the square brackets [ ]</li></ul>.\n",
    " <ul><li> Out of the three parameters, having at least one value or parameter when using the square brackets [ ] is compulsory (as in a[0]).</li></ul>\n",
    " <ul><li> So we can use either 1, 2 or upto 3 parameters in square brackets, and each of these parameters is seperated using \"colons\" (:)</li></ul>\n",
    " <ul><li> The parameters are denoted as follows -> [<i>start</i>:<i>stop</i>:<i>step</i>] (notice the colons been used to seperate the parameters as mentioned in the above point</li></ul>\n",
    " <ul><li> <i>start</i> parameter decides from which index we are supposed to start. </li></ul>\n",
    " <ul><li> <i>stop</i> parameter decides at which index we are supposed to stop (it goes upto n-1 index, so if we choose say (a[0:3]), we will get characters in \"apple\" from 0th index to 3-1=2 (n-1), so a[0:3] will return \"app\" from 0th, 1st and 2nd index). Here even though we just used [<i>start</i>:<i>stop</i>] in a[0:3], the <i>step</i> parameter was by default set to 1, i.e. in the back-end python was executing a[0:3:1], because by default, the <i>step</i> parameter is set at 1, when we use both <i>start</i> and <i>stop</i> parameters inside the square brackets.</li></ul>\n",
    " <ul><li> <i>step</i> parameter is used for skipping the characters or stepping on them as we count from left to right. For eg : a[0:5:2] (here we have purposefully used '2' as the step so python knows not to use \"1\" as the value for the step parameter by default).<br>So, for a[0:5:2], we will start at a[0]=>\"a\",jump two indices and go to a[2]=>\"p\" and go on until 5-1=4 index,so a[4]=\"e\". So a[0:5:2]=>\"ape\" (Start at 0, stop at 5-1=4, jump two indices every step). Notice how we can use \"5\" as stop value as well because <i>stop</i> parameter only considers n-1 as a value.</li></ul>\n",
    " <ul><li> In case only one parameter is involved (like in a[0]), we get the value at that specific index (\"a\" in \"apple\" for a[0]). Because here, we only consider the value at that specific index, here a[0].</li></ul>\n",
    " <ul><li>In case two parameters are given then python only considers them as [<i>Start</i>:<i>Stop</i>] with <i>Step</i> set at 1 by default in the back-end by python itself. Eg : a[0:4]=>\"appl\" (From 0th index to n-1 (4-1=3) index).</li></ul>\n",
    " <ul><li> In case all three parameters are given [<i>start</i>:<i>stop</i>:<i>step</i>] it works the same way as explained in case of a[0:5:2] above.</li></ul>\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "1m2tcFZkMZ_G",
    "outputId": "b2624425-d8ab-490a-e2d2-715f93a4fd1f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ello world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello world\"\n",
    "# Grab everything past the first term all the way to the length of s till the end\n",
    "print (s[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "D2z2YjkYPYWi",
    "outputId": "258b1ebb-b0a0-42a3-ee8e-79f89ce4c320"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# Note that there is no change to the original s variable\n",
    "s = \"hello world\"\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "BA_H4M-mPZv9",
    "outputId": "d124b8b8-26a9-4de1-d26a-821cca395f8f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hell\n"
     ]
    }
   ],
   "source": [
    "s = \"hello world\"\n",
    "# Grab everything UP TO the 4th index (n-1 = 4-1 = 3rd index, indices till 3rd will be printed)\n",
    "print (s[:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "9HYdpV-iPe_S",
    "outputId": "a4fcf8c8-9ceb-4695-df84-6bd8fafba8f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "#Everything\n",
    "s = \"hello world\"\n",
    "print (s[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "ElLG0rD8Pjy3",
    "outputId": "a8b41264-36ea-4cc3-e5cb-30b4e839bb3e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello worl\n"
     ]
    }
   ],
   "source": [
    "# Grab everything but the last letter\n",
    "s = \"hello world\"\n",
    "print (s[:-1])    \n",
    "#Start here is considered as \"Everything\", you can notice that only one single colon is used meaning [start:stop] parameters\n",
    "#are used while step is considered as 1 by default by python. Stop parameter is set to n-1 (-1-1=-2) so return everything till -2 index\n",
    "#step as 1 (set by python, even though we are only using the parameters [start:stop])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "QSQVSWHJPpEG",
    "outputId": "12cc3b7a-2b87-49d6-ef8a-14148bfa8578"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# Grab everything, but go in steps size of 1\n",
    "print (s[::1])  \n",
    "#Here start and stop parameter are considered as \"everything is included\" and we are considering three parameters as you can notice\n",
    "#unlike above example, we have two colons in square brackets so the parameters now include [start:stop:step] but since start and stop aren't\n",
    "#mentioned, it will include everything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "G3bHxqANPtMN",
    "outputId": "427d7e77-0215-4c0a-d30b-eef62813748a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hlowrd\n"
     ]
    }
   ],
   "source": [
    "# Grab everything, but go in step sizes of 2\n",
    "s = \"hello world\"\n",
    "print (s[::2])\n",
    "#Here, yet again [start:stop:step] are used\n",
    "#start = 0th index \n",
    "#stop = last index is included (Basically include everything as start and stop aren't mentioned implicitly)\n",
    "#step = set as 2 by us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "colab_type": "code",
    "id": "zXbS5OMqQtoc",
    "outputId": "5a3c4970-2931-4c9d-9d56-52972d51664c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlrow olleh\n"
     ]
    }
   ],
   "source": [
    "# We can use this to print a string backwards\n",
    "s = \"hello world\"\n",
    "print (s[::-1])\n",
    "#Grab everything but start from the last index (negative one step) and go on to the start parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Tukjf7KeRei0"
   },
   "source": [
    "<a id=\"9C iv. String properties\"></a>\n",
    "<br><br><b><u>(iv.) String Properties</u> :</b><br> \n",
    "It's important to note that strings have an important property known as *immutability*. This means that once a string is created, the elements within it can not be changed or replaced. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "bV6h01eURy0E",
    "outputId": "88968691-faa0-4dd7-ccb2-ddeb649f4c18"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello world\"\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 231
    },
    "colab_type": "code",
    "id": "J4Gd43gBR0d5",
    "outputId": "5a7b8d22-d31e-4a6e-8943-6f8b0a29f2be"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-99-21fdf30a429e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Let's try to change the first letter to 'x'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"hello world\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'x'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[1;31m#This was the reason I was using \"=>\" To denote a[0]=>\"a\" in above examples, as saying a[0]=\"a\" means you are trying to\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m#change the value/character at a[0] which is not allowed in string datatype.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Let's try to change the first letter to 'x'\n",
    "s = \"hello world\"\n",
    "s[0] = 'x'\n",
    "#This was the reason I was using \"=>\" To denote a[0]=>\"a\" in above examples, as saying a[0]=\"a\" means you are trying to\n",
    "#change the value/character at a[0] which is not allowed in string datatype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fUWWH4tkSLy0"
   },
   "source": [
    "---------------------------------------------------------------------------------\n",
    "Notice how the error tells us directly what we can't do, change the item assignment!\n",
    "\n",
    "Something we *can* do is concatenate strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dRhcqcEsSNxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello world\"\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Az4z0GkwSP80"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!! I am batman\n"
     ]
    }
   ],
   "source": [
    "# Concatenate strings!\n",
    "s = \"hello world\"\n",
    "print (s + '!! I am batman')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PDwk0XYASYOk"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "#Notice how the original value of variable s is not changed\n",
    "#Make sure you have run the above 2 cells to see the output without error here\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3V6lJ510S8jp"
   },
   "outputs": [],
   "source": [
    "# We can reassign the variable s completely though!\n",
    "#Make sure you have run the above 3 cells to see the output without error here\n",
    "s = s + ' I am batman!'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "C3DeNeJlTYot"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world I am batman!\n"
     ]
    }
   ],
   "source": [
    "#The value of s is now reassigned\n",
    "#Make sure you have run the above 4 cells to see the output without error here\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8uJspIKLVzw6"
   },
   "source": [
    "<a id=\"9C v. String methods & functions\"></a>\n",
    "<br><br><b><u>(v.) Basic Built-in String methods and functions</u> : </b>\n",
    "\n",
    "Objects in Python usually have built-in methods and functions. These methods are functions inside the object that can perform actions or commands on the object itself.\n",
    "\n",
    "We call functions with a period/dot and then the function name. Functions are in the form:\n",
    "\n",
    "object.function-name(parameters)\n",
    "\n",
    "Where parameters are extra arguments we can pass into the method/functions. Don't worry if the details don't make 100% sense right now. Later on we will be creating our own objects and functions!\n",
    "\n",
    "Here are some examples of built-in methods/functions in strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "O1Fd1xVmWWvq"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |      \n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |  \n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |      \n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |      \n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found, \n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |      \n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |      \n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |  \n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |      \n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |      \n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers such as \"def\" and\n",
      " |      \"class\".\n",
      " |  \n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |      \n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |  \n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |      \n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |  \n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |      \n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |      \n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |  \n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |      \n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |      \n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |      \n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |  \n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |  \n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |  \n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |      \n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |      \n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |  \n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |        sep\n",
      " |          The delimiter according which to split the string.\n",
      " |          None (the default value) means split according to any whitespace,\n",
      " |          and discard empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits to do.\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Splits are done starting at the end of the string and working to the front.\n",
      " |  \n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |      sep\n",
      " |        The delimiter according which to split the string.\n",
      " |        None (the default value) means split according to any whitespace,\n",
      " |        and discard empty strings from the result.\n",
      " |      maxsplit\n",
      " |        Maximum number of splits to do.\n",
      " |        -1 (the default value) means no limit.\n",
      " |  \n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |      \n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |  \n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |      \n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |  \n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |      \n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |      \n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |  \n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |      \n",
      " |      The string is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"str\")  \n",
    "#notice how I am using str with small 's'. Python is case-sensitive, never forget that\n",
    "#This will return all the functions and methods we can use with strings.\n",
    "#press 'q' on the keyboard if you are in interactive/terminal mode of python to exit the help menu.\n",
    "#this is not the terminal/interactive mode of python by the way :P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "arRsezOW6pkp"
   },
   "source": [
    "<b><u> Note : </b></u>  There's a difference between **str** and **string** in python. Especially if you consider <b>help(\"str\")</b> and <b>help(\"string\")</b>. <br><br>\n",
    "**str** is a datatype (It is also a **class** but more on \"class\" later) it is used to work with letters and symbols while <b>string</b> is a module/library which consists of added functions to work with strings {such as <b>string.lower</b> gives as a string from a to z \"abcde....xyz\"}. More info on this can be found [here](https://stackoverflow.com/questions/2026038/relationship-between-string-module-and-str). )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TwHd9oALeuRq"
   },
   "source": [
    "We will try to cover as many of these built-in methods and functions which are popular and generally used. You can always check the internet for the function or method that you don't understand or which is not covered here.<Br>\n",
    "Few points before we begin with string functions and methods :\n",
    "* If you look at the methods and functions mentioned in help(str) you can see that in the begining some are followed by <code><pre> __ add__ </code></pre>This means that this is a method and can be applicable on other data types like list, dictionaries, etc as well. Methods can be universal but a function most probably would not.\n",
    "* If you scroll down further in the help menu, you will notice now functions names like : Capitalize, center, count shown as follows :\n",
    "<code><pre>capitalize(...)\n",
    " |      S.capitalize() -> str\n",
    " |      \n",
    " |      Return a capitalized version of S, i.e. make the first character\n",
    " |      have upper case and the rest lower case.</pre></code>\n",
    " These are functions and follow the syntax as :\n",
    " <code>object.function-name(parameters_if_any)</code><Br> or\n",
    " <br><code>variablename.function-name(parameters_if_any).</code>\n",
    " <Br> Since we are talking about string functions here, the variable (which infact is the object of string class as well), should be holding a string value (like in case of s=\"hello world\") to be able to use string functions.<Br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "krtuGO_38uFw"
   },
   "source": [
    "<a id=\"9C vi. String methods\"></a>\n",
    "<br><br><b><u>(vi.) Methods used with str</u> :</b><br>\n",
    " Now, let's get started with the methods of <code>str</code> and see how to use them.<br> \n",
    " <br><b>NOTE : </b>Make sure the first cell below is run for all the other cells to work as they use the common variable 'z' to run, if the first cell below isn't run all will give errors.<br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VstYqzC6eiP4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power rangers were so boring at times.\n"
     ]
    }
   ],
   "source": [
    "z = \"power rangers\"   \n",
    "print (z.__add__(\" were so boring at times.\")) #The __add__ method works the same way as concatenation works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pI1zqmErhVPM"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power rangers\n"
     ]
    }
   ],
   "source": [
    "#Make sure you have run the above cell to see the output without error here\n",
    "print (z)   #but it isn't permanent like concatenation either"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EqQu0Ry5hZ8o"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power rangers have lost the match\n"
     ]
    }
   ],
   "source": [
    "#Make sure you have run the above 2 cells to see the output without error here\n",
    "print (z + \" have lost the match\") \n",
    "#As you can see using + operator for concatenation method or __add__ is the same thing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-fgYDLiGh3Mb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#By now you must have realized that the basic syntax for methods is as follows :\n",
    "\n",
    "#variable-name.__methodname__(parameters-if-any)\n",
    " \n",
    "#or\n",
    "\n",
    "#object-name.__methodname__(parameters-if-any)\n",
    "#lets use contains method\n",
    "print (z.__contains__(\"p\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QlN2a-bciQPs"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (z.__contains__(\"i\"))  #as you can see, it checks if a specific character exists in the string or not.\n",
    "#Here we tried to find \"p\" and \"i\" in \"power rangers\" and we got True and False respectively as \"p\" is present while \"i\" isn't."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s38wSVFYimBo"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "#__eq__ method stands for \"Equal to\" and it checks if the string is exactly equivalent to the string assigned to the variable.\n",
    "print (z.__eq__(\"rangers power\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PNFPVYXWiuSU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(z.__eq__(\"power rangers\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xmtnfIzHlUX4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#__ge__stands for 'greater than equal to'\n",
    "print(\"hello\".__ge__(\"hello\"))  \n",
    "#We can directly use \"strings\" in double-quotes as well, because in the end variables point to \n",
    "#\"string_values\" itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w1NXrlywlqaM"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\".__ge__(\"hell\"))  #hello>=hell (True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AZTZaZRMlvm6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\".__ge__(\"hello world\"))  \n",
    "#Don't forget the dot/period operator between the methods and the string/variables/object\n",
    "#here, \"hello\">=\"hello world\" (False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MKqa7GbCl2_y"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#__gt__ stands for 'greater than'\n",
    "print (\"hello\".__gt__(\"hello\"))  #hello>hello (False) __gt__method\n",
    "print (\"hello\".__ge__(\"hello\"))  #hello>=hello (True) __ge__method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0Op8SRdzmGGo"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"hi\".__gt__(\"h\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-HjVB46d9squ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1631650316125606053\n",
      "-1631650316125606053\n"
     ]
    }
   ],
   "source": [
    "#The hash() method or .__hash__()\n",
    "print(z.__hash__())\n",
    "    #or\n",
    "print (hash(z))  #both will give the same output\n",
    "\n",
    "#The hash() method returns the hash value of an object if it has one.\n",
    "#Hash values are just integers which are used to compare dictionary keys during a dictionary lookup quickly.\n",
    "#Internally, hash() method calls __hash__() method of an object which are set by default for any object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2SwQ60o2_mHD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tv variable - \n",
      "\n",
      "h\n",
      "e\n",
      "y\n",
      "\n",
      "\tn variable - \n",
      "\n",
      "h\n",
      "e\n",
      "y\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-119-e4aeb426dba6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m#2nd iteration\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m#3rd iteration\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m#j = \"hey\" has only 3 characters, so it can be iterated only 3 times, this 4th iteration will cause an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#The iter() method or .__iter__()\n",
    "#Just like hash() some methods can also be called as special functions like iter(),hash() and len(), and str()\n",
    "#you don't need to use __iter__(), you can just use iter() as well.\n",
    "#Definition of iter():\n",
    "        #The iter() method creates an object which can be iterated one element at a time.\n",
    "        #These objects are useful when coupled with loops like for loop, while loop.\n",
    "j = \"hey\"\n",
    "v = iter(j)\n",
    "n = j.__iter__()  #traditional way but both give the same output\n",
    "\n",
    "print (\"\\tv variable - \\n\")        #\\n prints to next line\n",
    "print (next(v))  \n",
    "print (next(v))            #next() is used to print the next iteration\n",
    "print (next(v))\n",
    "\n",
    "print (\"\\n\\tn variable - \\n\")\n",
    "print (next(n))   #1st iteration\n",
    "print (next(n))   #2nd iteration\n",
    "print (next(n))   #3rd iteration\n",
    "print (next(n))   #j = \"hey\" has only 3 characters, so it can be iterated only 3 times, this 4th iteration will cause an error\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"9C vi.> Len and type\"></a>\n",
    "<br><b>Some important functions in Python : (len & type)</b><br><br>\n",
    "<li> <u> len() </u> : It tells the length of a string or container data-types like list, tuples, sets, etc.\n",
    "<li> <u> type() </u> : It tells us the data-type of the value passed inside the type() function.\n",
    "<br><br>    \n",
    "    <b>Eg : </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cf6hx0-YB0pL"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "25\n",
      "33\n",
      "5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#len() or .__len__()\n",
    "#len() is used to get the lenght of the string, lists, tuples, etc. It doesn't work for datatypes that aren't container datatypes\n",
    "#dictionaries, etc or don't have indices like strings,lists,etc. Meaning it won't work for integers & floats as you can't\n",
    "#find length of a number but you can find how many characters does a string have\n",
    "\n",
    "print(len(\"This is a long sentence\"))\n",
    "p = \"This is a longer sentence\"\n",
    "print (len(p))\n",
    "print ( \"This is a longest setence I guess\".__len__() )\n",
    "print (len(\"hello\"))  #5 characters in \"hello\", hence the length will be 5 but indices are from 0 to 5-1=4.\n",
    "#don't get confused between length and indices.\n",
    "h = \"meh\"\n",
    "print (h.__len__())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zomhGj1uKUII"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#Some more important methods\n",
    "#type() method lets you check the dataype of any value or any variable that is holding any datatype\n",
    "\n",
    "a = \"apple\"\n",
    "print (type(a))\n",
    "print (type(1))\n",
    "b = 1.2\n",
    "print (type(b))\n",
    "print (type(\"Funny\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Let's continue with <b>str</b> functions once again now that we have discussed <b>len()</b> and <b>type()</b> functions.\n",
    "\n",
    "---\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eMRPI1INDf7T"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#__le__ method stands for \"less than equal to\" and is similar to __eq__,__gt__ and __ge__ methods\n",
    "print (\"h\".__le__(\"hey\"))\n",
    "h = \"meh\"\n",
    "print (h.__le__(\"m\"))   \n",
    "print (h.__le__(\"meh\"))  #meh>=meh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_WWlxPzeEiwo"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#__lt__ method stands for \"less than\" and is similar to __eq__,__ge__,__gt__ and __le__ methods\n",
    "h = \"meh\"\n",
    "print(h.__lt__(h)) #meh<meh (False)\n",
    "print (h.__lt__(h[0]*5)) #meh<mmmmm (True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uqftLSUYFOFJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey! hey! hey! hey! hey! \n",
      "hey! hey! hey! hey! hey! hey! hey! \n",
      "30\n",
      "57\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "#__mul__ stands for Multiply and is used to multiply a string multiple times.\n",
    "print (\"hey! \".__mul__(5)) #Multiply 'hey' 5 times\n",
    "#It is the same as :       #Multiply 'hey' 7 times\n",
    "print (\"hey! \"*7)\n",
    "\n",
    "print (len(\"hey\"*10))  #Some improvisation examples with len() and .__len__\n",
    "print (len(\"hey\".__mul__(19)))\n",
    "print (\"hey\".__mul__(7).__len__())  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8bbjlRsvGGIU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#__ne__ stands for 'Not equal to' and is opposite of  __eq__ method (equal to method)\n",
    "a = \"apple\"\n",
    "print (a.__ne__(a[0]))\n",
    "print (a.__ne__(a[:]))  \n",
    "#here a[:],a and \"apple\" are the same thing which is \"apple\" and hence, we get false as \"apple\" is equal to apple\n",
    "print (a.__ne__(a))\n",
    "print (a.__ne__(\"apple\"))\n",
    "\n",
    "#but\n",
    "print (a.__eq__(a[:]))  #as \"apple\" is equal to \"apple\"\n",
    "\n",
    "#IMPORTANT :\n",
    "#Kindly try not to \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GTd4di_wGvI6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "And he quoted: 'The world is burning slowly~' and left with a sad expression.\n",
      "'Hey'\n",
      "Hey\n"
     ]
    }
   ],
   "source": [
    "#__repr__ method, \n",
    "#It is used to put a string in single quotes and is useful while maintaining those single quotes during print statement\n",
    "print (\"And he quoted:\",\"The world is burning slowly~\".__repr__(),\"and left with a sad expression.\")\n",
    "print (\"Hey\".__repr__()) #with __repr__\n",
    "print (\"Hey\")            #without __repr__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uzUqqit3JFyq"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54\n",
      "58\n"
     ]
    }
   ],
   "source": [
    "#__sizeof__ method returns the size of the string in memory, in bytes.\n",
    "\n",
    "a = \"apple\"\n",
    "print (a.__sizeof__())\n",
    "print (\"not apple\".__sizeof__())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fEE321bNJeLR"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "9\n",
      "99 pizzas didn't fill his stomach\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-128-8355d8a89d14>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m\" pizzas didn't fill his stomach\"\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#string concatenation\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m      \u001b[1;31m#This will cause error as variable 'a' is still holding on to integer value of 9\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m                  \u001b[1;31m#and concatenation of string and integers is not possible.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "#__str__ or str() method : Converts any datatype to a string value\n",
    "a = 9\n",
    "b = a.__str__()  #Converting int to str datatype\n",
    "print (b)\n",
    "c = str(a)       #Same thing but using str() instead\n",
    "print (c)\n",
    "print (b+c+\" pizzas didn't fill his stomach\")  #string concatenation\n",
    "print (a+b)      #This will cause error as variable 'a' is still holding on to integer value of 9\n",
    "                 #and concatenation of string and integers is not possible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bMAxYcaNKvw5"
   },
   "source": [
    "<a id=\"9C vii.String functions\"></a>\n",
    "<br><br><b><u>vii.) Functions used with str</u> :</b><br>\n",
    "When we run <code>help(str)</code>, after scrolling down a bit you will see methods with the double underscores on both sides, and after that comes functions which use the (.) dot operator.<br>\n",
    "Something like this :<br>\n",
    "<code><pre>capitalize(...)\n",
    " |      S.capitalize() -> str\n",
    " |      \n",
    " |      Return a capitalized version of S, i.e. make the first character\n",
    " |      have upper case and the rest lower case.</pre></code>\n",
    " <br>\n",
    " The basic syntax of functions is :<br>\n",
    " <pre><code>\n",
    " s = \"Text\"\n",
    " s.function-name(parameters-if-any) #Notice the usage of dot operator after the variable. Eg:\n",
    " s.capitalize()  #capitalize function doesn't have any parameters\n",
    " </code></pre>\n",
    " One thing that is worth noting here is that we can use functions of strings with any string value or variable that is assigned a string value (just like in case of methods. This will be clear in further examples below.\n",
    " Let's explore the most conmmonly used functions of string module/data type :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TfZldhdssIdP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a text\n",
      "this is a text\n",
      "This is a text\n",
      "This is a text. this is an another text\n"
     ]
    }
   ],
   "source": [
    "#capitalize() function : Takes no parameters or arguments inside the paranthesis\n",
    "\n",
    "a = \"this is a text\"\n",
    "print (a.capitalize())  #Notice the \"T\" in \"this\" in \"this is a text\" in the output. It gets capitalized.\n",
    "print (a)               #Also notice how the original string value has not changed, to change the original string we need to reassign it\n",
    "a = a.capitalize()     #reassigning the value of variable a with a.capitalize() value\n",
    "print (a)               #The value will be capitalized now\n",
    "print (\"this is a text. this is an another text\".capitalize())\n",
    "#Capitalize only makes the first letter capital, it doesn't care about full stops as\n",
    "#in this example. Notice how I didn't use an variable to call the function just the string. This is what happens also when we use an variable.\n",
    "#Python subsitutes the string value of the variable in the back-end for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "R5QnrPpSToL7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     hello     \n",
      "     hello     \n",
      "$$$$$hello$$$$$\n",
      "15\n",
      "Width is 4 :  hello\n",
      "Width is 5 :  hello\n",
      "Width is 6 :  hello$\n",
      "Width is 7 :  $hello$\n",
      "Width is 14 :  $$$$hello$$$$$\n"
     ]
    }
   ],
   "source": [
    "#center() function : Takes two parameters and one arguement (Meaning only one parameter is compulsory to be filled inside the paranthesis)\n",
    "#center() has two parameters which are (width,fill). Width expects integer value and is compulsory to fill, fill is a string data type and\n",
    "#isnt' compulsory to fill.\n",
    "\n",
    "s = \"hello\"\n",
    "#print (s.center())         This won't work as center() function atleast expects you enter one parameter. Hence I commented this statement.\n",
    "print (s.center(15))        #By default, width here is set to 15, while fill is set to \" \"  (empty space)\n",
    "print (s.center(15,\" \"))    #This will give the same output as above statement\n",
    "print (s.center(15,\"$\"))    #here the spaces will be set to $ (dollar) symmbol\n",
    "print (len(s.center(15,\"$\"))) #Notice how the final lenght isn't 15+5=20 where 15 is width and 5 is lenght of \"hello\"\n",
    "#center function just adds the character \"$\" on both the sides of the string \"hello\" until \"hello\" is in center\n",
    "\n",
    "print (\"Width is 4 : \",s.center(4,\"$\"))     #This won't work as we want to add width of 4 overall but the string \"hello\" itself is of length 5\n",
    "print (\"Width is 5 : \",s.center(5,\"$\"))     #won't have any change\n",
    "print (\"Width is 6 : \",s.center(6,\"$\"))     #will add a \"$\" at the end to make the final width as 5+1=6 (here, 5 is length of \"hello\")\n",
    "print (\"Width is 7 : \",s.center(7,\"$\"))     #adds dollar symbols on both sides to make overall length as 7.\n",
    "print (\"Width is 14 : \",s.center(14,\"$\"))   #adds 4 $ symbols on left and 5 $ symbols on right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2C2lC6FpZ0vt"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0\n",
      "1\n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#count() function : Takes one parameter which is a string value in the paranthesis\n",
    "s = \"hello\"\n",
    "print (s.count(\"l\"))  #Returns the count of how many times the letter \"l\" appears in \"hello\"\n",
    "print (s.count(\"z\"))  #Returns how many times \"z\" appears in \"hello\"\n",
    "print (s.count(\"h\"))  #Returns how many times \"h\" appears in \"hello\"\n",
    "print (s.count(\"he\")) #Returns the count of how many times \"he\" appears in \"hello\"\n",
    "\n",
    "\n",
    "#this is an important function for questions like : How many times is \"s\" repeating in \"mississippi\"\n",
    "print (\"mississippi\".count(\"s\"))  #Returns 4 as \"s\" appears 4 times in \"mississippi\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ub7Lnfq1au4L"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#endswith() function : Accepts one string value as a parameter in the paranthesis\n",
    "s = \"hello\"\n",
    "print (s.endswith(\"o\"))   #Accepts one string value in the paranthesis as the parameter\n",
    "#Returns boolean value (True or False) whether a string ends with a specific letter or character or not.\n",
    "\n",
    "print (s.endswith(\"s\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jp7625JWbTGH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0\n",
      "-1\n",
      "-1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#find() function : Accepts one string value as a parameter in paranthesis\n",
    "\n",
    "a = \"hello\"\n",
    "print (s.find(\"l\"))    #returns the index of the first instance of the string passed inside the paranthesis (here it is letter \"l\")\n",
    "#for the given string, here \"l\" is first spotted at index 2, hence it will return 2 ignoring another \"l\" at index 3 \n",
    "\n",
    "print (s.find(\"h\"))    #returns 0 for index 0 as \"h\" is at index 0 in \"hello\"\n",
    "\n",
    "print (s.find(\"z\"))    #returns -1 as the character \"z\" does not exist in \"hello\" Not to be confused with negative indices as explained before.\n",
    "print (s.find(\"H\"))    #returns -1 as character \"H\" is not present in \"hello\" (python is case-sensitive, it treats \"H\" and \"h\" differently)\n",
    "print (\"abcabcabc\".find(\"b\"))  #returns 1 as letter \"b\" is spotted at index 1 first. It will always return the lowest index value where it finds\n",
    "#the letter \"b\" first, that is the first instance of letter \"b\" in \"abcabcabc\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EBs6Oj0Tcd92"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "2\n"
     ]
    },
    {
     "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)",
      "\u001b[1;32m<ipython-input-134-4963a527ebcf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"o\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#returns 4 as \"o\" is located at index 4 in \"hello\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"l\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#returns 2 as the first instance of \"l\" or the lowest index of \"l\" is at index 2 in \"hello\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"z\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#returns \"ValueError\" as \"z\" is not present in \"hello\". Here, find() function would have returned -1 instead of an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m                       \u001b[1;31m#as we can see from the example above.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "#index() function : Accepts one string value as the parameter inside the paranthesis\n",
    "#Index works the same way as find() function, that is, it returns the lowest index where it first spotted the letter which was \n",
    "#passed inside the paranthesis but the only difference is, if a letter is not found in the actual string\n",
    "#it will raise \"ValueError\" instead of returning -1 in case of find() function\n",
    "#This is useful in case of exception handling where we can ignore the error and still make the code work.\n",
    "a = \"hello\"\n",
    "print (a.index(\"h\"))  #returns 0 as \"h\" is located at index 0 in \"hello\"\n",
    "print (a.index(\"o\"))  #returns 4 as \"o\" is located at index 4 in \"hello\"\n",
    "print (a.index(\"l\"))  #returns 2 as the first instance of \"l\" or the lowest index of \"l\" is at index 2 in \"hello\"\n",
    "print (a.index(\"z\"))  #returns \"ValueError\" as \"z\" is not present in \"hello\". Here, find() function would have returned -1 instead of an error\n",
    "                      #as we can see from the example above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sf7fyz_7d0HZ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isalnum() function : Accepts no values as parameters in the paranthesis\n",
    "#alnum stands for \"is alphanumeric\" or \"is aplphabet or numeric\" \n",
    "#It checks whether each character in a given string is either an alphabet or number\n",
    "#if not, then it returns False else it returns True\n",
    "a = \"hello\"\n",
    "b = \"hello123\"\n",
    "c = \"123\"\n",
    "d = \"hello 123\"  #notice the whitespace in between of \"hello\" and \"123\"\n",
    "\n",
    "print (a.isalnum())   #Returns True as all the letters in variable a are alphabets\n",
    "print (b.isalnum())   #Returns True as all the letters in variable b are alphabet or numbers\n",
    "print (c.isalnum())   #Returns True as all the letters in variable c are numbers\n",
    "print (d.isalnum())   #Returns False as whitspace between \"hello\" and \"123\" is neither a number nor an alphabet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0DT9f-vofq1X"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isalpha() function : Accepts no values as parameters in the paranthesis\n",
    "#isalpha() stands for \"is alphabet\" checks if each character in a given string is an alphabet or not\n",
    "#if it is an alphabet it returns True or else it returns false\n",
    "\n",
    "a = \"hello\"\n",
    "b = \"hello123\"\n",
    "c = \"123\"\n",
    "d = \"hello world\"  #notice the whitespace in between of \"hello\" and \"world\"\n",
    "e = \"hello-world\"\n",
    "\n",
    "print (a.isalpha())   #Returns True as all the letters in variable a are alphabets\n",
    "print (b.isalpha())   #Returns False as all the letters in variable b are alphabet or numbers. Every character isn't an alphabet.\n",
    "print (c.isalpha())   #Returns False as all the letters in variable c are numbers and not alphabets. \n",
    "print (d.isalpha())   #Returns False as whitspace between \"hello\" and \"hello\" is not an alphabet.\n",
    "print (e.isalpha())   #Returns False as \"-\" in \"hello-world\" is not an alphabet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0wrotxLCghpN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#isdecimal() function : Accepts no values as parameters in the paranthesis\n",
    "#isdecimal() does exactly what it sounds like. It checks if a given string is a decimal or not.\n",
    "#Please do not confuse decimal for float values like (1.2, 2.434, 3.14 etc). Decimal here refers to decimal in case of\n",
    "#binary, oct, decimal, hexa-decimal\n",
    "\n",
    "a = \"1.5\"\n",
    "b = \"hello-to-only-1.5-of-you-humans\"\n",
    "c = \"hello to only 1.5 of you humans\"\n",
    "d = \"0123\"\n",
    "\n",
    "print (a.isdecimal())   #1.5 is not a decimal no. (It's a float)\n",
    "print (b.isdecimal())   #Not decimal\n",
    "print (c.isdecimal())   #Not decimal\n",
    "print (d.isdecimal())   #This is decimal as decimal system has numbers from 0 to 9 only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RE1qPgmksaJ9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#isdigit() function : Takes no parameter in paranthesis\n",
    "#Works the same way as isdecimal() function the \n",
    "a = \"1.5\"\n",
    "b = \"hello-to-only-1.5-of-you-humans\"\n",
    "c = \"hello to only 2 of you humans\"\n",
    "d = \"0123\"\n",
    "\n",
    "print (a.isdigit())   #1.5 is not a digit (decimal no.)\n",
    "print (b.isdigit())   #Not digit\n",
    "print (c.isdigit())   #Not digit\n",
    "print (d.isdigit())   #This is a digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ywpdkU-kviat"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isnumeric() function : \n",
    "#Works in the same way as isdigit() and isdecimal() but also recognizes no.s in other languages such as chinese no.s 1,2,3\n",
    "#etc in this case.\n",
    "print ('一二三四五'.isnumeric())\n",
    "print (\"1234\".isnumeric())\n",
    "print (\"abc21\".isnumeric())\n",
    "print ('一二三四五'.isdigit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7QPpy39ySvZ7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#islower() function:\n",
    "#Checks if every letter in a string is lowercase or not. \n",
    "\n",
    "a = \"hello234\"\n",
    "b = \"Hello\"   #H is capital\n",
    "c = \"223\"\n",
    "d = \"hiii\"\n",
    "\n",
    "print (a.islower())\n",
    "print (b.islower())\n",
    "print (c.islower())\n",
    "print (d.islower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dMuaAK4vVCmJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#isspace() function :\n",
    "#Checks if the given string value is only spaces or not\n",
    "\n",
    "a = \"hello world\"   #has letters too beside the space in between \"hello\" and \"world\"\n",
    "b = \"     \"  #Only spaces\n",
    "c = \"\\t\\t\"   #\\t is an escape sequence which is used to give tab-space. One \\t => 8 spaces hence this is also true\n",
    "\n",
    "print (a.isspace())\n",
    "print (b.isspace())\n",
    "print (c.isspace())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BluLEnA5WNRc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#isupper() function :\n",
    "#Just like islower() function it checks that if every character in a string is uppercase or not\n",
    "\n",
    "a = \"HENLO\"\n",
    "b = \"Henlo\"\n",
    "c = \"HENLO123\"\n",
    "d = \"henlo123\"\n",
    "e = \"1234\"\n",
    "\n",
    "print (a.isupper())\n",
    "print (b.isupper())\n",
    "print (c.isupper())\n",
    "print (d.isupper())\n",
    "print (e.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cqT0rVncYgUu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "ahellob\n",
      "ahellob hellochellodhello e\n",
      " a hello b hello c hello d \n",
      "$$ hello $$\n"
     ]
    }
   ],
   "source": [
    "#join() function\n",
    "#It takes a list consisting of elements as string values as the parameter or arguement and joins them together with the initial\n",
    "#variable value\n",
    "#Eg:\n",
    "\n",
    "a = \"hello\"\n",
    "b = [\"a\"]     #Here, b is a variable which is assigned a list having the string element \"a\" as it's first element\n",
    "c = [\"a\", \"b\"]#Here, c is a list which is having \"a\" as first index and \"b\" as second element\n",
    "d = [\"a\",\"b \",\"c\",\"d\",\" e\"]\n",
    "e = [\" a \", \" b \", \" c \", \" d \"] #Notice how variable b,c and d are all holding string values only (not integer, float, etc)\n",
    "# I will be talking about lists in detail later \n",
    "\n",
    "print (a.join(b))\n",
    "print (a.join(c))\n",
    "print (a.join(d))   #Notice \n",
    "print (a.join(e))   #Notice the spaces and how hello is \n",
    "print (a.join([\"$$ \",\" $$\"]))  #Directly using the list as the parameter inside the paranthesis of join() function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "XtcPKXjmeYeN",
    "outputId": "1fdbe1e6-7a47-4c72-c40e-adf0afa033f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "#lower() function\n",
    "#It converts uppercase strings to lowercase and if it is already lowercase it doesn't do anything. Eg :\n",
    "a = \"hello\"\n",
    "b = \"HELLO\"\n",
    "c = \"hElLO\"\n",
    "print (a.lower())      #all letters are already lowercase\n",
    "print (b.lower())      #all letters will be made lowercase\n",
    "print (c.lower())      #only letters that are uppercase will be made lowercase rest all if they are lowercase will remain the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Th', 'i', 's is a random text')\n",
      "('This is a ', 'ra', 'ndom text')\n",
      "('', 'T', 'his is a random text')\n"
     ]
    }
   ],
   "source": [
    "#partition() function\n",
    "\"\"\"partition(self, sep, /)\n",
    " |      Partition the string into three parts using the given separator.\n",
    " |\n",
    " |      This will search for the separator in the string.  If the separator is found,\n",
    " |      returns a 3-tuple containing the part before the separator, the separator\n",
    " |      itself, and the part after it.\n",
    " |\n",
    " |      If the separator is not found, returns a 3-tuple containing the original string\n",
    " |      and two empty strings.\n",
    " \"\"\"\n",
    " #As per the documentation definition of partition, it partitions a string in three parts always, based on the character\n",
    " #or string passed inside it. It always returns a tupple and considers the first occurance of the string value passed\n",
    " #inside the paranthesis. Eg:\n",
    "\n",
    "a = \"This is a random text\"\n",
    "print (a.partition(\"i\"))  #first occurance of \"i\" will be seperated by 3 parts : ('Th', 'i', 's is a random text')\n",
    "print (a.partition(\"ra\"))\n",
    "print (a.partition(\"T\"))  #obviously, be careful of case-sensitivity, here the first split will be empty '', \n",
    "                          #because the occurance of \"T\" is in first index and there is nothing before it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Th@s @s a random text or @s @t?\n",
      "Th@s @s a random text or is it?\n",
      "This is a random text or is it?\n"
     ]
    }
   ],
   "source": [
    "#replace() function\n",
    "#It replaces all the substrings inside a string with the value passed inside the replace function.\n",
    "#EG:\n",
    "\n",
    "a = \"This is a random text or is it?\"\n",
    "print (a.replace(\"i\",\"@\")) #output is : Th@s @s a random text or @s @t?\n",
    "                           #all the \"i\" has been replace with \"@\"\n",
    "print (a.replace(\"i\",\"@\",2)) #Here, 2 is a parameter (more on parameters later) which is optional and let's us\n",
    "                             #tell how many first occurances of \"i\" we want to replace. So here,\n",
    "                             #out of 4 \"i\", we only want to replace the first two \"i\", that's why the output is:\n",
    "                             #Th@s @s a random text or is it?  (last two i's remain the same)\n",
    "            \n",
    "print (a.replace(\"y\",\"a\"))   #Nothing is replaced as \"y\" isn't present in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This', 'is', 'a', 'random', 'text']\n",
      "['Th', 's ', 's a random text']\n",
      "['This is a random ', 'ex', '']\n",
      "\n",
      "This is the value of b :  +91 123456789\n",
      "\n",
      "This is the value of c :  ['+91', '123456789']\n",
      "\n",
      "This is the value of d :  +91123456789\n"
     ]
    }
   ],
   "source": [
    "#split() function  [IMPORTANT FUNCTION - commonly used in string and list handling problems]\n",
    "#This is used to split a string just like partition function but instead it splits at every occurance the value passed\n",
    "#inside it is found at. This is usually used to remove spaces between words in string handling cases. \n",
    "#It returns list instead of tuple unlike in partition function. Eg:\n",
    "\n",
    "a = \"This is a random text\"\n",
    "print (a.split(\" \"))  #passing space (not empty)\n",
    "print (a.split(\"i\"))\n",
    "print (a.split(\"t\"))\n",
    "\n",
    "#This is usually used hand in hand with join function (mentioned above) :\n",
    "b = \"+91 123456789\"   #consider a random phone no. string\n",
    "print (\"\\nThis is the value of b : \",b)  #More about significance of \\n later (it basically prints an empty new line)\n",
    "c = b.split(\" \")\n",
    "print (\"\\nThis is the value of c : \",c)\n",
    "d = \"\".join(c)  #\"\" denotes an empty string (different from \" \", this is a space, notice how their is a gap in space)\n",
    "                #so basically we join an empty string with the elements inside the list, c.\n",
    "          \n",
    "print (\"\\nThis is the value of d : \",d) #The output is value of b but without spaces\n",
    "\n",
    "#You can also use split to convert string to list and then use list functions like sort, reverse, etc to arrange\n",
    "#letters in ascending or reversed order and then use join function to make it a string again. Though you can\n",
    "#also use string[::-1] as mentioned above for string reversal.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#startswith() function\n",
    "#It is used to determine if a string starts with a particular letter or string or not.\n",
    "#It returns true if the value passed in startwith() function is the starting value for the given string, or else false.\n",
    "#It's opposite of endswith() function. EG:\n",
    "\n",
    "z = \"A for Apple, B for ball\"\n",
    "print (z.startswith(\"A\"))\n",
    "print (z.startswith(\"a\"))  #case-sensitivity matters\n",
    "print (\"Hello World!\".startswith(\"H\"))  #here directly checking a string instead of using a variable holding a string val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Monkey likes bananas     \n",
      "Monkey likes bananas\n",
      "Monkey likes bananas\n",
      "Monkey likes bananas\n"
     ]
    }
   ],
   "source": [
    "#strip() function\n",
    "#It returns the given string after removing any extra spaces before or after the given string, if present. Eg:\n",
    "\n",
    "m = \"      Monkey likes bananas     \"\n",
    "n = \"Monkey likes bananas\"\n",
    "o = \"Monkey likes bananas      \"\n",
    "print (m)\n",
    "print (m.strip())\n",
    "print (n.strip()) #since no extra spcaces are present it won't do anything and return it as it is.\n",
    "print (o.strip()) #the right side spaces are removed but telling the difference is hard until used with other strings\n",
    "                  #later on for concatenation or such methods, the white space won't be concatenated if strip() is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NeW DelhI Is The CapiTAL Of INdIa\n"
     ]
    }
   ],
   "source": [
    "#swapcase() function\n",
    "#Converts uppercase strings to lowercase and lowercase strings to uppercase. Eg :\n",
    "\n",
    "a = \"nEw dELHi iS tHE cAPItal oF inDiA\"\n",
    "print (a.swapcase())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New Delhi Is The Capital Of India\n",
      "New delhi is the capital of india\n"
     ]
    }
   ],
   "source": [
    "#title() function\n",
    "#Makes the first letter of every string after a spcae as uppercase and makes the rest as lowercase.\n",
    "#It is similar to capitalize() function but capitalize() only makes the first letter as capital not every word \n",
    "#after space. Eg:\n",
    "\n",
    "a = \"nEw dELHi iS tHE cAPItal oF inDiA\"\n",
    "print (a.title())\n",
    "print (a.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "THESE WERE ALL SMALL LETTERS, BUT WERE THEY? \n",
      "\n",
      "\n",
      "A MIX OF UPPER AND LOWER CASE STRING\n",
      "a mix of upper and lower case string\n",
      "a Mix oF UpPeR and LowEr CasE StriNG\n",
      "A Mix Of Upper And Lower Case String\n",
      "A mix of upper and lower case string\n"
     ]
    }
   ],
   "source": [
    "#upper() function\n",
    "#converts all lower case function to uppercase. It's the opposite of Lowercase function. Eg:\n",
    "\n",
    "a = \"these were all small letters, but were they?\"\n",
    "print (a.upper(),\"\\n\\n\")\n",
    "b = \"A mIX Of uPpEr AND lOWeR cASe sTRIng\"\n",
    "print (b.upper())  #converts all to upper case\n",
    "print (b.lower())  #coverts all to lower case\n",
    "print (b.swapcase()) #converts all to ALTERNATE case of their existing case\n",
    "print (b.title())  #only first letter of EVERY word is made uppercase case, rest becomes lowercase\n",
    "print (b.capitalize()) #only first letter of FIRST word is mader uppercase, rest becomes lowercase \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><hr></b>\n",
    "These are one of the most commonly used functions of str but there are a few more left which haven't been mentioned and aren't used as widely as the ones mentioned above. You can always explore the rest remaining functions using \n",
    "<code>help(\"str\")</code><br>\n",
    "In your python prompt window.\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"9D Boolean data type\"></a>\n",
    "<h3> <u><b>(d.) Boolean Data type (True or False)</b></u></h3><br>\n",
    "This datatype has only two values which are <code><b>True</b></code> and <code><b>False</b></code> (mind the case-sensitivity, T in True is always capital and F in False). <code>True</code> and <code>False</code> are reserved keywords as well which are used usually with conditional statements (if-else) to check whether a given condition is <b>True</b> or <b>False</b>. I guess it will be clearer with examples : <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print (7<8)  #True\n",
    "print (8<7)  #False\n",
    "print (10>2) #True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also the output that few functions give when they are used. We have come across some of them in str functions.\n",
    "Eg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = \"hello\"\n",
    "print (a.islower()) #True\n",
    "print (a.isupper()) #False\n",
    "print (a.startswith(\"h\")) #True\n",
    "print (a.startswith(\"H\")) #False\n",
    "\n",
    "#We can use this output with if-else conditions to make confirmations for string handling problems and continue\n",
    "#if a condition for the problem is True or False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><br>\n",
    "<a id=\"9D i. Comparison Operators\"></a>\n",
    "<b><u>(i.) Comparison Operators in Python</b></u><br>\n",
    "Bool or Boolean values are usually used with <b>Comparison Operators</b> which are also used in \"In-equality algebra\" in mathematics. These comparison operators are the same as the ones in C and C++ language. Let's go through them all of them :\n",
    "<br>\n",
    "<pre>\n",
    "1. <code><b>==</code></b>\tIf the values of two operands are equal, then the condition becomes true.\t\n",
    "2. <code><b>!=</code></b>\tIf values of two operands are not equal, then condition becomes true.\n",
    "3. <code><b>></code></b>\tIf the value of left operand is greater than the value of right operand, then condition becomes true.<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Similar to !=.</li>\n",
    "4. <code><b><</code></b>\tIf the value of left operand is less than the value of right operand, then condition becomes true.\n",
    "5. <code><b>>=</code></b>\tIf the value of left operand is greater than or equal to the value of right operand, then condition becomes true.\n",
    "6. <code><b><=</code></b>\tIf the value of left operand is less than or equal to the value of right operand,<br> then condition becomes true.\n",
    "    </pre><br><b>Eg :</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 :  True\n",
      "2 :  False\n",
      "3 :  False\n",
      "4 :  True\n",
      "7 :  True\n",
      "8 :  False\n",
      "9 :  False\n",
      "10 :  True\n",
      "11 :  True\n",
      "12 :  True\n",
      "13 :  True\n",
      "14 :  False\n"
     ]
    }
   ],
   "source": [
    "print (\"1 : \",99==99) #True\n",
    "print (\"2 : \",90==99) #False\n",
    "print (\"3 : \",99!=99) #False\n",
    "print (\"4 : \",90!=99) #True\n",
    "print (\"5 : \",4.8 > 4.7)  #True\n",
    "print (\"6 : \",4.8 > 4.8)  #False\n",
    "print (\"7 : \",4.8 < 2.1)  #False\n",
    "print (\"8 : \",2.1 < 4.8) #True\n",
    "print (\"9 : \",4.8>=4.8) #True\n",
    "print (\"10 : \",4.8>=4.7)  #False\n",
    "print (\"11 : \",1.2<=1.2)  #True\n",
    "print (\"12 : \",1.2<= 1.1)  #False       \n",
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"9E Complex data type\"></a>\n",
    "<h3><u><b>(e.) Complex Numbers Data type (True or False)</b></u></h3><br>\n",
    "In Mathematics, we use complex numbers to deal with [imaginary numbers.](https://www.mathsisfun.com/numbers/imaginary-numbers.html) Imaginary Numbers are used to denote numbers such as square root of -1 or any negative no.<br>\n",
    "Imaginary no. is of the form, <code>REAL NO. + IMAGINARY No.</code>, in python, we use <code>Int Value/float value + j</code> to denote the same. Here, \"j\" is not a variable as it is on the right hand side of the assignment operator (=).<br>\n",
    "<b>Eg : </b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+1j)\n",
      "(2.4+5j)\n",
      "1j\n",
      "10\n",
      "(10+1j)\n",
      "\n",
      "Sum of variable d and d1 :  (20+1j)\n",
      "\n",
      "Sum of variable a and b :  (3.4+6j)\n"
     ]
    }
   ],
   "source": [
    "a = 1 + 1j    #The 'j' on the right side denotes squareroot of -1, while 1 is the real no. \n",
    "b = 2.4 + 5j  #The 5 in front of 'j' is a real no. multiplied with sqaureroot of -1 (5j) while 2.4 is the real no.\n",
    "\n",
    "#c = j        #This will give error, as python will look for variable 'j' and not consider this 'j' as an imaginary no.\n",
    "              #Since we haven't declared any variable 'j' (we have only declared variables 'a' and 'b'), python\n",
    "              #will give error. This can be rectified by putting a one(1) in front of this 'j'. Here, one (1) is\n",
    "              #the real number. Now python recognizes the 'j' as an imaginary no. and doesn't give error. \n",
    "\n",
    "c1 = 1j       #This is the right way to do it. Here, c1 is hodling a complex number data-type\n",
    "\n",
    "j = 10        #Let's say we declare variable 'j' now, and use it to assign it to another variable 'd'\n",
    "d = j         #Printing variable 'd' won't give error now as, python now has variables 'a','b','c1' and 'j'. But,\n",
    "              #variable 'd' is holding on to an integer value, not complex number data-type.\n",
    "\n",
    "d1 = 10 + 1j  #For complex data-type, having the real-no. or integer or float data-type in addition with 'j' is important.\n",
    "              #This is a complex no. data-type.\n",
    "print (a)\n",
    "print (b)\n",
    "print (c1)\n",
    "print (d)\n",
    "print (d1)\n",
    "print (\"\\nSum of variable d and d1 : \",d+d1)  #Only real no. parts are added\n",
    "print (\"\\nSum of variable a and b : \",a+b)    #Since, imaginary no. part exists for both, real & imaginary parts\n",
    "                                              #both are added.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "To work with complex no.s, you need to know the domain of imaginary no.s in mathematics and it's usage. But in real-life,\n",
    "imaginary no.s aren't really used for practical purposes and hence aren't really considered a very important mathetmatic\n",
    "topic to be aware of."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"9F None data type\"></a>\n",
    "<h3><u><b>(f.) None Data type (None)</b></u></h3><br>\n",
    "None Data Type in python is used to denote the null value. It is declared in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "a = None         #Notice, \"N\" in None, case-sensitivity is important\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code><b>None</b></code> Data-type is used as a place-holder for variables that you aren't sure of what value to assign yet. You can use them to assign them a null value and wait till you get a proper value from an user. Hence,\n",
    "many times in user-defined functions, parameters are passed with <b>None</b>.<br>\n",
    "<br>Some important facts about None Data-type:\n",
    "<ul><li> None is not to be confused with True or False. They are different things. </li>\n",
    "<li> None is not equal to zero (0). 0 is an integer data-type and has mathemetical importance. None is Void. </li>\n",
    "<li> None is not an empty string. As mentioned before, empty string is denoted as, a=\"\". </li>\n",
    "<li> Comparing None to anything will always return False except None itself.</li></ul><br> Eg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "print (a==None)  #True\n",
    "print (a==False) #False\n",
    "print (a==True)  #False\n",
    "print (a==0)     #False\n",
    "print (a==\"\")    #False, comparing to empty string\n",
    "print (a==\" \")   #False, comparing to empty space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "---\n",
    "<a id=\"10. Looping Statements in Python\"></a>\n",
    "<h3><b>10. <u>Looping Statements in Python (For & While Loop)</h3></b></u>\n",
    "\n",
    "\n",
    "---\n",
    "<br><b><u>(i.) Need for Looping Statements </u> : </b><br>\n",
    "<a id=\"10. i Need for looping statements in python\"></a>\n",
    "Loop Statements are special features of any good programming language as they allow a programmer to execute a block of code under the looping statement multiple times until a required condition is met. This helps us by not having to repeat and type the same piece of code again and again.<br>\n",
    "One thing to keep in mind is the <b>\"Flow of Code\"</b> meaning how the code is run by the python interpreter. Most beginners don't keep this in mind and mess up the output as they execute the wrong line of code at the wrong time causing common errors such as <b>\"Index out of range\"</b> (in case of arrays/list elements calling).\n",
    "\n",
    "<a id=\"10. ii For loop staments\"></a>\n",
    "<br><br><b><u>(ii.) For loop Statements in Python (Syntax & Usage)</u> : </b><br><br>\n",
    "In C language, we wrote the code in the following way for FOR loops :<br>\n",
    "<code>for (i=0;i&lt;10;i++)\n",
    "                    {\n",
    "                       printf(\"%d\",i);\n",
    "                       printf(\"\\n\");\n",
    "                    }\n",
    "</code>\n",
    "<br>\n",
    "* Here, variable \"i\" is known as the looping variable which keeps count of how many times a loop needs to run (here, i value starts from 0 goes to on 9 (as i<10 or i==9)).\n",
    "* <b>i++</b> us known as the increment operator, this is responsible for incrementing or increasing the value of \"i\" by 1 after each loop statement is executed. <b>i++</b> is equivalent of <b>i = i + 1</b>, in the first loop, <b>i = 0</b>, so <b>i = i + 1</b> becomes <b> i = 0 +1</b> so in next loop, <b>i = 1</b>, then \"i\" becomes <b>i = 1+1</b> or <b>i=2</b> in the next loop. This goes on until <b>i&lt;10</b>or <b>i = 9</b>.\n",
    "* The Curly Braces {} are responsible for executing the statements under the FOR loop mutliple times until the loop condition is meant. It tells the C compiler that until this for loop doesn't change from i=0 to i=9, keep repeating the block of code under {} which is <br>\n",
    "                    {\n",
    "                       printf(\"%d\",i);\n",
    "                       printf(\"\\n\");\n",
    "                    }<br>\n",
    "  So these two printf() statements will be printed 10 times (i=0 to i=9 is 10 times worth of counting).\n",
    "\n",
    "  <br>\n",
    "  ---\n",
    "  <br>In Python, we use the [keyword](https://www.programiz.com/python-programming/keyword-list) <b>\"for\"</b> just as in C or C++ language to run a for loop but we also use another keyword called as <b>\"in\"</b> and function called as <b>range()</b> function with it. Hence, the for loop in python is very different than in C or C++ language.\n",
    " <br>The basic syntax for <b>for loop</b> in python goes as : <br><br>\n",
    " <code>for looping_variable in range(0,10):</code><br> \n",
    " <br>\n",
    " Example of the C code above in python language would be the following :\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "\n",
      "\n",
      "1\n",
      "\n",
      "\n",
      "2\n",
      "\n",
      "\n",
      "3\n",
      "\n",
      "\n",
      "4\n",
      "\n",
      "\n",
      "5\n",
      "\n",
      "\n",
      "6\n",
      "\n",
      "\n",
      "7\n",
      "\n",
      "\n",
      "8\n",
      "\n",
      "\n",
      "9\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    print (i)\n",
    "    print (\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "So what is happening here?<br>\n",
    "<ul>\n",
    "<li> <b>\"for\"</b> is a keyword and is used by us to let python know that we are using a \"for-loop\". The characteristic of for loop is that, it has a beginning, an end and in some cases a skip value (more about these later). But, \"for\" is same as in C language, we type \"for\" and python interpreter knows okay a \"for loop\" is going to be executed here.</li>\n",
    "    \n",
    "<li> <b>looping_variable</b> here is \"i\", just how we had in C or C++ langauge. It can be any variable, it doesn't really matter. But make sure you are using the same variable and not some other variable if you want to use the changing values of \"i\" as in this case. Meaning, I used <b>print(i)</b> not print(k) or anything else, since only variable \"i\" is changing from values 0 to 9 not any other variable.</li>\n",
    "    \n",
    "<li> <b>\"in\"</b> is a keyword and is used with secondary or container data-types (list, arrays, tuples, sets, etc are such data-types) mostly to make python interpreter understand that we are talking about the values or elements insde this secondary data type. Understand it in the same way how you understand the english word \"in\". <Br><b>Eg:</b>The apples are \"in\" the basket.<br> Now this basket is the container data-type and using the keyword \"in\" you are going through Apple No. 1, Apple No. 2, etc until the basket gets over. This will be clearer with further examples of \"for-loops\" later.</li>\n",
    "<li> <b>range()</b> function is the most tricky one to understand but let's try our best to understand it. <b>range()</b> is a generator function, meaning it generates a collection or group of numbers containing integers values for a specific range. But on it's own it's not really a secondary-data type but more of it's own data-type called as \"range\" data-type which temporary holds the range of numbers. But on it's own, it's not useful, we need to [type-cast](https://techterms.com/definition/typecasting#:~:text=Terms%20%3A%20Typecasting%20Definition-,Typecasting,an%20integer%20to%20a%20string.) to a secondary data-type or use it in \"for-loops\" using keywords like \"in\" which give access to range of numbers held by this weird unusable data-type.<br><br>The arguments or parameters that range() function accepts are as follows : <br><br><code>range(starting_int_value, ending_int_value, skip_int_value)</code><br><br></li>\n",
    "    ** Here, <b>\"start_int_value\"</b> is the starting point of your range, i.e., where do you want to start your range from.<br>\n",
    "    ** Here, <b>\"ending_int_value\"</b> is the value you want to end your range at, but in range() function  will always return values upto <b>n-1</b> value of the \"ending_int_value\".<br>\n",
    "    ** Here, <b>\"skip_int_value\"</b> acts as the counter, i.e., the decrement or increment manager like how we had <b>i++</b> or <b>i--</b> in C or C++.<br><br>\n",
    "    Now, in this only <b>\"ending_integer_value\"</b> is an argument or a compulisory parameter to be passed inside the range() function and range() function will always return values upto <b>n-1</b> value of the <b>\"ending_int_value\"</b> as mentioned before. Obviously like most functions, you cannot pass range() function without any parameters or empty.<br><br> Let's try to understand this with an example (Kindly read the comments to understand deeply) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "range expected 1 arguments, got 0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-160-0e629a20b09d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#Here, we will run range() function without passing no arguments or any parameter in it.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m#see how we will get TypeError telling as range expected \"1 argument\" but got 0,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m                   \u001b[1;31m#so we need to at least pass 1 value inside the paranthesis for it to make it work\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: range expected 1 arguments, got 0"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 1 : range()\n",
    "\n",
    "#Here, we will run range() function without passing no arguments or any parameter in it.\n",
    "\n",
    "print (range())   #see how we will get TypeError telling as range expected \"1 argument\" but got 0,\n",
    "                  #so we need to at least pass 1 value inside the paranthesis for it to make it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'float' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-161-956932f6f851>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m#paranthesis of range() function and see how it goes.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m7.7\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#Obviously we will get a \"TypeError\" because, python expects you to enter an integer value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m                     \u001b[1;31m#inside the range() function to make it work\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 2 : range(ending_float_value)\n",
    "\n",
    "#Here, we will pass the wrong data-type (float) instead of the right data type (int) inside the \n",
    "#paranthesis of range() function and see how it goes.\n",
    "\n",
    "print (range(7.7))  #Obviously we will get a \"TypeError\" because, python expects you to enter an integer value\n",
    "                    #inside the range() function to make it work\n",
    "    \n",
    "#So at least one \"integer\" argument is required to make the range() function work properly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EXAMPLE 3 : range(ending_int_value)\n",
    "\n",
    "print (range(10))   #A range data-type will be outputted. This holds the value from 0 to 9 but we cannot access it\n",
    "                    #on it's own until we type-cast it to a secondary data-type like list or tuples\n",
    "                    #or use this function with for-loop and \"in\" keyword.\n",
    "\n",
    "# NOTE :       \n",
    "#The range data-type evaluated is known as \"Lazy Evaluation\" which is a feature of python. Python instead of\n",
    "#evaluating a full output (which should be a list, see next code block for list(range(n))),\n",
    "#Python doesn't full evaluate the output until each loop of the for-loop is executed.\n",
    "#This saves memory consumption and time-consumption though we end up with an unusable data-type of range() function.\n",
    "\n",
    "\n",
    "print (type(range(10)))   #To check the data-type of range() function output.\n",
    "                          #The output is going to be class \"range\" or data-type range which is not useable on \n",
    "                          #it's own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#EXAMPLE 4 : range(ending_int_value) with type-casting to secondary data-type\n",
    "\n",
    "#Here, we type-cast or change the data-type from range data-type to a list and see the expanded range values inside it.\n",
    "\n",
    "print (list(range(10)))   #A list data-type will be outputted from 0 to 9 (where, 9 is n-1 of 10, if n = 10, \n",
    "                          #then values will be printed till 9, not 10)\n",
    "\n",
    "#list() function is used to convert container data-types to a list data-type.\n",
    "\n",
    "#Notice how I haven't mentioned all the 3 parameters which are : \"starting_int_value\", \"ending_int_value\" and\n",
    "#\"skip_int_value\" and that I have only mentioned one parameter which is \"ending_int_value\" \n",
    "#(Not the other parameters : start_int_value or skip_int_value as they aren't compulsory and range() function will work\n",
    "#without them as well but not without ending_int_value). Here, when you pass only 1 value inside the python takes it \n",
    "#for \"ending_int_value\" only. \n",
    "\n",
    "#Here, python itself adds a default value for \"starting_int_value\" and \"skip_int_value\" which are,\n",
    "# start_int_value = 0   (start from i=0 by default if nothing is mentioned)\n",
    "# skip_int_value = 1    (keep the increment at i++ or i=i+1 by default if nothing is mentioned)\n",
    "\n",
    "#Hence, that's why even though we don't mention it our range starts from 0 and is incremented by 1 only."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "We can conclude one thing with the following above examples. <br>\n",
    "<b>range()</b> function needs at least <u>one \"integer\" argument</u> and has <u>two optional arguments</u> (also known as parameters).<br>\n",
    "Here, the one compulsory argument is the \"ending_int_value\" because python cannot decide where we want to end the range.<br>\n",
    "The other optional parameters (not arguments per say, but parameters) are \"starting_int_value\" and \"skip_int_value\"\n",
    "because even if you don't mention them, python by default sets, start_int_value = 0 and skip_int_value = 1.\n",
    "<br><b>Eg : </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 5 : range(starting_int_value, ending_int_value, skip_int_value)\n",
    "\n",
    "#here, we will keep start_int_value = 0\n",
    "                    #end_int_value = 10\n",
    "                    #skip_int_value = 1 \n",
    "        \n",
    "print (list(range(0,10,1)))  #Notice how we get the same output as above example. \n",
    "\n",
    "#This is because as I mentioned, python defaults start_int_value & skip_int_value 0 and 1 respectively even if \n",
    "#you don't mention them.\n",
    "\n",
    "#But we can obviously change it as per our wishes by manually mentioning them. \n",
    "#Check the next examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 6(a) : range(start_int_value, end_int_value)\n",
    "\n",
    "print (list(range(1,11)))  #Notice how I still haven't given 3 parameters but only 2.\n",
    "                           #Here, start_int_value = 1 (mentioned manually by me, but not compulsary)\n",
    "                           #Here, end_int_value = 11 (mentioned manually by me, but is compulsary. It will print till\n",
    "                                    #10 since, n-1 of 11 is 11-1=10)\n",
    "                           #Here, skip_int_value = 1 (set by python on its own to default value 1)\n",
    "            \n",
    "#Now since I have manually mentioned the start_int_value, python won't use the default value for start_int_value\n",
    "#which is 0.\n",
    "\n",
    "#ALso notice, how we get range from 1 to 10, not 0 to 11 or 0 to 10 as we get n-1 of 11 which is 10 and we mentioned\n",
    "#and as to why it begans with 1 and not 0, I already mentioned in the line above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 6(b) : range(start_int_value, end_int_value)\n",
    "\n",
    "print (list(range(11,1)))  #Notice how I still haven't given 3 parameters but only 2.\n",
    "                           #Here, start_int_value = 11 (mentioned manually by me, but not compulsary)\n",
    "                           #Here, end_int_value = 1 (mentioned manually by me, but is compulsary. It should print till 0\n",
    "                                    #coz n-1 of 1 is 1-1=0)\n",
    "                           #Here, skip_int_value = 1 (set by python on its own to default value 1)\n",
    "            \n",
    "#Now since I have manually mentioned the start_int_value, python won't use the default value for start_int_value\n",
    "#which is 0.\n",
    "\n",
    "#But, since the \n",
    "   #start_int_value > end_int_value\n",
    "    #and the increment is by positive 1 (by default), we cannot decrease (going from 11 to 1 is descending order)\n",
    "    #hence python won't print anything as our generated list will be empty. (Refer to example 7(c) for more details)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 7(a) : range(start_int_value, end_int_value,skip_int_value)\n",
    "\n",
    "print (list(range(2,21,2)))  #Here, I have given 3 parameters (all of them) so no default values will be used.\n",
    "                             #Here, start_int_value = 2 (begins at 2 since I manually set it)\n",
    "                             #Here, end_int_value = 21 (will print till 20 (n-1 of 21), set by me)\n",
    "                             #Here, skip_int_value = 2 (Here, the increment will now be by 2, i.e, i = i + 2,\n",
    "                                     #so it will skip by 2 and give us an even series, set by me manually)\n",
    "                \n",
    "#This is the multiplication table of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 7(b) : range(start_int_value, end_int_value,skip_int_value)\n",
    "\n",
    "print (list(range(3,31,3)))  #Here, I have given 3 parameters (all of them) so no default values will be used.\n",
    "                             #Here, start_int_value = 3 (begins at 3 since I manually set it)\n",
    "                             #Here, end_int_value = 31 (will print till 20 (n-1 of 31), set by me)\n",
    "                             #Here, skip_int_value = 3 (Here, the increment will now be by 3, i.e, i = i + 3,\n",
    "                                     #so it will skip by 3 and give us an odd series, set by me manually)\n",
    "                \n",
    "#This is the multiplication table of 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 0, -3, -6, -9, -12, -15, -18, -21, -24, -27, -30]\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 7(c) : range(start_int_value, end_int_value, skip_int_value)\n",
    "\n",
    "print (list(range(30,-31,-3))) #Here, I have given 3 parameters (all of them) so no default values will be used.\n",
    "                               #Here, start_int_value = 30 (begins at 30 since I manually set it)\n",
    "                               #Here, end_int_value = -31 (will print till -30 (n+1 of -31, -31+1= -30), set by me)\n",
    "                                        #In case of negative \"end_int_value\", it prints till n+1 of n, here, n = -31\n",
    "                                        #so, it will print till n+1 of it, i.e., -31 + 1 = -30.\n",
    "                               #Here, skip_int_value = -3 (Here, the decrement will now be by -3, i.e, i = i - 3,\n",
    "                                        #so it will skip by 3 and give us an odd negative series, set by me manually)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 27 24 21 18 15 12 9 6 3 0 -3 -6 -9 -12 -15 -18 -21 -24 -27 -30 "
     ]
    }
   ],
   "source": [
    "#EXAMPLE 8(a): Implementing range() function with for-loops\n",
    "\n",
    "#We saw how to use range() functions with list() function but the same principle is used for \"For-loop\" as well.\n",
    "#As mentioned earlier, the keyword \"in\" helps us to access the unusable range of numbers that are in the range data type.\n",
    "#The \"in\" keyword kind of treats the range data-type as a temporary list and goes through each element or value \n",
    "#from first index to the last index and then outputs them.\n",
    "\n",
    "#Eg:\n",
    "for i in range(30,-31,-3): #The colon (:) are equivalent of curly braces {} in C or C++ language.\n",
    "    print (i,end=\" \")       #Notice the \"indentation\" of print() is inside the for-loop, the print() function isn't\n",
    "                           #directly under the for keyword, I have added a gap (4 spaces or 1 tab space to be exact)\n",
    "                           #to let python know that this print() function is related to the for loop and is to be\n",
    "                           #repeated until the for-loop is completed and that this print() function isn't to be\n",
    "                           #just printed once.\n",
    "                    \n",
    "                           #end=\" \" , refers to print in the same line and add a space.\n",
    "                                     #By default, everytime one loop is completed\n",
    "                                     #python will print the next integer value of \"i\" under the next line, but\n",
    "                                     #due to end=\" \", it will print it in the same line and adds \" \" (an empty space)\n",
    "                                     #at the end of it.\n",
    "                                     #try only, print(i) and print(i,end=\"\") and print (i,end=\"$\") to see the difference. \n",
    "\n",
    "    #This is wrong way to use indentation:\n",
    "    \n",
    "#for i in range(30,-31,-3):\n",
    "#print (i,end=\"\")          #Notice how no extra tab space or spaces follow before the print() function so python\n",
    "                           #will interpret it as a statement that is independent of the for-loop statement\n",
    "                           #but a for-loop statement needs to have atleast one line of code under it\n",
    "                           #so we will get any error as here, python thinks that under for-loop we have no block of code\n",
    "                           #only.\n",
    "\n",
    "            \n",
    "#Notice how the output isn't surrounded by [] (square brackets) as in examples 4 to 7 as the output isn't a \n",
    "#list data-type but just a range of numbers printed one after the other.\n",
    "#This is because we are using for-loop and \"in\" keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLE 8(b): Implementing for-loops with only 2 parameters (similar to example 6(a))\n",
    "\n",
    "for i in range(10,20):     #skip_int_value is set to \"1\" by default by python, since we haven't set any value manually\n",
    "    print (i)              #since, end=\" \" isn't used, all the values will be printed in next line.\n",
    "                           #and not in the same line.\n",
    "    \n",
    "    #Output is printed till n-1 of 20 which is 19."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"10. iii Nested for loop\"></a>\n",
    "<br><b><u>(iii.) Nested For loop Statements </u> : </b><br><br>\n",
    "Nested \"for-loops\" refers to an inner for-loop inside an outer for-loop. This is usually done to execute matrix problems (problems containing 2D dimension, meaning row and columns, etc). Here, the inner for-loop is used for transvering or for travelling through the columns (From left to right, one column after another) while the outer for-loop is used for going to next row (understand it like going to next line of a table).<br>\n",
    "<br><b>Eg : </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The table of 2 is : \n",
      "\t2 x 1 = 2\n",
      "\t2 x 2 = 4\n",
      "\t2 x 3 = 6\n",
      "\t2 x 4 = 8\n",
      "\t2 x 5 = 10\n",
      "\t2 x 6 = 12\n",
      "\t2 x 7 = 14\n",
      "\t2 x 8 = 16\n",
      "\t2 x 9 = 18\n",
      "\t2 x 10 = 20\n",
      "\n",
      "The table of 3 is : \n",
      "\t3 x 1 = 3\n",
      "\t3 x 2 = 6\n",
      "\t3 x 3 = 9\n",
      "\t3 x 4 = 12\n",
      "\t3 x 5 = 15\n",
      "\t3 x 6 = 18\n",
      "\t3 x 7 = 21\n",
      "\t3 x 8 = 24\n",
      "\t3 x 9 = 27\n",
      "\t3 x 10 = 30\n",
      "\n",
      "The table of 4 is : \n",
      "\t4 x 1 = 4\n",
      "\t4 x 2 = 8\n",
      "\t4 x 3 = 12\n",
      "\t4 x 4 = 16\n",
      "\t4 x 5 = 20\n",
      "\t4 x 6 = 24\n",
      "\t4 x 7 = 28\n",
      "\t4 x 8 = 32\n",
      "\t4 x 9 = 36\n",
      "\t4 x 10 = 40\n"
     ]
    }
   ],
   "source": [
    "#Printing multiplication table from 2 to 4.\n",
    "\n",
    "for i in range(2,5):\n",
    "    #This is the outer loop\n",
    "    print (\"\\nThe table of %d is : \"%(i))   #Here, %d is acting as a place-holder for printing values of i\n",
    "    for j in range(1,11):\n",
    "        #This is the inner loop\n",
    "        print (\"\\t%d x %d = %d\"%(i,j,i*j))  #in first left-most %d, value of \"i\" will be printed\n",
    "                                            #in second mid %d, value \"j\" will be printed\n",
    "                                            #in last right-most %d, value of i*j will be printed\n",
    "                \n",
    "#Here, the inner-loop (looping_variable \"j\") will run first from 1 to 10 values while the value of \"i\"\n",
    "#from outer-loop will remain the same.\n",
    "     #First loop -> when i=2 (since, start_int_value of outer loop is \"2\"), j will change from 1 to 10.\n",
    "     #Second loop -> when i=3 (\"i\" gets incremented by 1), j will once again gets initialized from 1 and get incremented\n",
    "                      #till 10.\n",
    "     #third loop -> when i=4 (last loop as n-1 of 5 is 4, and 5 is the end_int_value of outer loop)\n",
    "                    #variable \"j\" will change from 1 to 10 again.\n",
    "        \n",
    "#Understand that only the outer loop is getting looped \"thrice\", hence three loops, but within each of these 3 loops,\n",
    "#the inner loop is looped 10 times (from 1 to 10), so the inner loop technically \n",
    "#runs 3*10 = 30 times (outer_loop_count x inner_loop_count = total_inner_looop_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Like this we can have multiple nested loops until required. As demonstrated from above example, you can see that examples 7(a) and 7(b) where implemented using one nested for-loop instead of two seperate for-loops as shown in 7(a) and 7(b).\n",
    "<br><br>Nested for-loops are very important concept in <b>competitive programming</b> as most people get confused with the flow of the program when it comes to \"Nested for loops\""
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "colab": {
   "collapsed_sections": [],
   "name": "Python_Notes_by_Saket_Savarn.ipynb",
   "provenance": []
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}