basicworkshop.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy_of_basicWorkshop.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [
        "U4mvdVfTrDGh"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "colab_type": "text",
        "id": "3eOHupMXrDF4"
      },
      "cell_type": "markdown",
      "source": [
        "# BASIC PYTHON WORKSHOP\n",
        "\n",
        "## Basic Introduction to the Python Programming Language to kickstart your programming journey!\n",
        "\n",
        "Python is a popular programming language. It was created by Guido van Rossum, and released in 1991. Unlike C and C++ which are compiler languages, Python is an interpreter language. \n",
        "We're coding in Google Collab over here, but there are several other IDEs(Integrated Development Environment) like iDLE, xCode etc.\n",
        "\n",
        "\n",
        "##What can Python do?\n",
        "\n",
        "+ Python can be used on a server to create web applications.\n",
        "+ Python can be used alongside software to create workflows.\n",
        "+ Python can connect to database systems. It can also read and modify files.\n",
        "+ Python can be used to handle big data and perform complex mathematics.\n",
        "+ Python can be used for rapid prototyping, or for production-ready software development.\n",
        "\n",
        "##Lets's get started!\n",
        "\n",
        "`print` statement is the most basic `function` which is used to print an expression or variable in the console. \n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "BLHv8kWlrDF7",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Hello world\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "bk7tZvtMrDGB"
      },
      "cell_type": "markdown",
      "source": [
        "### What are expressions?\n",
        "\n",
        "Expressions are representations of value. They are different from 'statement' in the fact that statements do something while expressions are representation of value.\n",
        "\n",
        "Here are some examples of mathematical expressions."
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "ZzYRbjwEwa3T"
      },
      "cell_type": "markdown",
      "source": [
        "*Addition*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "BQ6gCeSerDGC",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "5+6"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "eCiSVnyvwdC0"
      },
      "cell_type": "markdown",
      "source": [
        "*Subtraction*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "3sERz5uirDGG",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "10-7"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "tneMk8FlwnAX"
      },
      "cell_type": "markdown",
      "source": [
        "*Multiplication*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "lMeNghpJrDGK",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "4*5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "g2dfNswDwpo_"
      },
      "cell_type": "markdown",
      "source": [
        "*Division*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ymeQlNZQrDGN",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "12/5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "pkyvDGGDwrw6"
      },
      "cell_type": "markdown",
      "source": [
        "*Modulus*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Xv88VsZkrDGQ",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "12%5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "56EPWBDswtlv"
      },
      "cell_type": "markdown",
      "source": [
        "*Exponent*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "uTgEBJIgrDGT",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "2**4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "qm_sgluArDGV"
      },
      "cell_type": "markdown",
      "source": [
        "#### Logical Expressions\n",
        "\n",
        "Returns a Boolean - `True` (1) or `False` (0) \n",
        "\n",
        "Some examples are listed below."
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "FuIE8wTtxFti"
      },
      "cell_type": "markdown",
      "source": [
        "*Check for Equality*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Lwo6azJmrDGW",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "1==1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "IogAFd2Fw-FS",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "1==2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "0kf4ATzxxI7U"
      },
      "cell_type": "markdown",
      "source": [
        "*Check for Unequality*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "5HdqZaEkw_o-",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "2!=1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "GyOgAdTyxSZt"
      },
      "cell_type": "markdown",
      "source": [
        "*AND Operator*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Y_t4qIyQxBAr",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "True & False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "M7Ejolsnxg6e"
      },
      "cell_type": "markdown",
      "source": [
        "*OR Operator*"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "CDC_TogHxCXh",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "True | False "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "5UufMUB5ytHc"
      },
      "cell_type": "markdown",
      "source": [
        "### __Precedence of Operators__\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1jI5_KsgoPHT8Fwz2bCPs-9UArOggw2Wp)\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "8hCcvTyfrDGm",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(10*3+4)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "Wah3SnIbrDGY"
      },
      "cell_type": "markdown",
      "source": [
        "### Q1. (True and False) or (False or True)"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Q3T7dROnu09o",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "(True and False) or (False or True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "U-2LVe5jrDGZ"
      },
      "cell_type": "markdown",
      "source": [
        "## Variables in Python\n",
        "\n",
        "Variables are basically symbolic representation of a memory space, which can be assigned to any expression, and can be then further used in functions, mathematical expressions and statements.\n",
        "\n",
        "Here, s is a variable which is assigned \"Hello World\" expression, and the print statement then prints 's' in the console, you can obviously guess the output."
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "P__WqYHxrDGa",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "s = \"Hello world\"\n",
        "\n",
        "print(s)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "tiiGvzGerDGb"
      },
      "cell_type": "markdown",
      "source": [
        "Mathematical Expressions can also be directly assigned to variables.\n",
        "\n",
        "Python does not require the programmer to declare the datatypes like String or Integer while declaring a variable and it follows a dynamic declaration process.\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ISGI7gZhrDGc",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = 9+5\n",
        "\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "NxXU75OfrDGe"
      },
      "cell_type": "markdown",
      "source": [
        "We can use the `type` function on a variable to know it's datatype."
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "KCthAO7K0-Wy"
      },
      "cell_type": "markdown",
      "source": [
        "## **Data Types in Python**\n",
        "\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1KOeNDvzilOofqCyh205F6o68_kLSKo9G)\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ietw6SlmrDGe",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "type(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "_S6jtGxxrDGg"
      },
      "cell_type": "markdown",
      "source": [
        "##### Rules for Variable Declaration\n",
        "\n",
        "There are certain rules that need to be followed while declaring a variable.\n",
        " \n",
        "![alt text](https://drive.google.com/uc?export=view&id=1qguNQDj1xi68eYU4mC_exZomu4N_9MZ8)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "U4mvdVfTrDGh"
      },
      "cell_type": "markdown",
      "source": [
        "### Apart from these rules, there are certain conventions that the programmers often follow.\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=19gdEyMLz2VXweB4paSYs--5MY7Y8Mpr8)"
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "pO1tFnVUrDGh"
      },
      "cell_type": "markdown",
      "source": [
        "## Basic Control Flows\n",
        "\n",
        "Control Flow allows the programmer to decide the final decision after passing through one or many logical checks.\n",
        "\n",
        "One such control flow is the `if` - `elif` - `else`. Let us see it in action.\n",
        "\n",
        "Make an if-else flow-chart. - image8"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "2qqxV3uLrDGi",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Will you attend the IEEELearn workshop? Input your decision\")\n",
        "\n",
        "decision = input(\"Please enter yes / no \\n\")\n",
        "\n",
        "decision = decision.lower()       #converts all characters to lowercase\n",
        "\n",
        "if(decision=='yes'):\n",
        "    print(\"PIZZA TIME!\")\n",
        "else:\n",
        "    print(\"Sorry, no pizza for you\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "-xDEJkqdrDGk"
      },
      "cell_type": "markdown",
      "source": [
        "### Important Syntax Points for if-elif-else\n",
        "-  Colon to mark the beginning of the suite\n",
        "-  Proper indentation for the suite of code\n",
        "\n",
        "You may noticed the use of two new functions here, `input` and `lower`\n",
        "\n",
        "`input` function enables the user of the program to input a **STRING** at run-time.\n",
        "You can pass an argument which you want to be the input prompt for the user. \n",
        "\n",
        "`lower` is a string function which converts the entire string to lowercase if their are any alphabets in it.\n",
        "\n",
        "Here is another similar example"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "gkypwKs93Ilk",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Enter number 1\")\n",
        "number1 = int(input())          #explicit casting (conversion) of data type from char to int - technical term is typecasting\n",
        "\n",
        "print(\"Enter number 2\")\n",
        "number2 = int(input())\n",
        "\n",
        "if (number1>number2):\n",
        "  print(number1, \"is greater than\", number2)\n",
        "  \n",
        "elif (number1<number2):\n",
        "  print(number1, \"is lesser than\", number2)\n",
        "  \n",
        "else:\n",
        "  print(number1, \"is equal to\", number2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "6UQKR0SlrDGo"
      },
      "cell_type": "markdown",
      "source": [
        "### Q2.Write a program to perform the following operations according to the input.<br>\n",
        "+ 1 - Perform addition\n",
        "+ 2 - Perform subtraction\n",
        "+ 3 - Perform multiplication\n",
        "+ 4 - Perform division\n",
        "+ Any other input - Display error message\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "OHRLbtKA0Ypy",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "AuilUKxMrDGp"
      },
      "cell_type": "markdown",
      "source": [
        "## Loops and Iterations\n",
        "\n",
        "We use several different types of loops to logically repeat certain expressions or statements, until a defined 'break' is reached.\n",
        "\n",
        "A loop in general has 3 components.\n",
        "-  Initialisation\n",
        "-  Check\n",
        "-  Updation"
      ]
    },
    {
      "metadata": {
        "id": "98TSkS9vyiDt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### `while` loop\n",
        "\n",
        "Syntax:\n",
        "\n",
        "```python\n",
        "while condition:\n",
        "    body\n",
        "```"
      ]
    },
    {
      "metadata": {
        "id": "bUtiG0rlywdk",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Here is a simple implementation of the `while` loop"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Z9RwoG4BrDGp",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "number=0                          #initialising number to 0\n",
        "\n",
        "while(number<6):                 #test condition \n",
        "    print(number)                 \n",
        "    number = number+1               #updation "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "pcA5i74brDGr"
      },
      "cell_type": "markdown",
      "source": [
        "`while` loop can be executed infinitely till the condition changes to False. It does not require a fixed number to iterate.\n",
        "\n",
        "\n",
        "`for` loop\n",
        "\n",
        "for loop is used to iterate a fixed number of times. There is always a counter variable which is incremented after each iteration.<br>\n",
        "\n",
        "\n",
        "Syntax:\n",
        "```python\n",
        "for var in seq:\n",
        "    loop body\n",
        "\n",
        "```"
      ]
    },
    {
      "metadata": {
        "id": "oKsfpKI-zZzu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Here is a simple implementation of the for loop. <br>\n",
        "`range()` returns a list of values from the start point to end point.\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "wmZ1Cf8VrDGs",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for number in range(0,5):      #range returns the list [1,2,3,4]. Note that it does not return 5\n",
        "    print(number)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "YijdVbg0rDGt"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "The 'in' keyword can also be used to iterate over a string, list or array.\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1-uMzL3y3EruWAv2qTcDGO7jO-IBp3LkX)"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "W6dw9FqQrDGu",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "word = \"python\"\n",
        "for letter in word:\n",
        "    print(letter)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "-f3Q-I1rrDGv"
      },
      "cell_type": "markdown",
      "source": [
        "## Counter Controlled vs. Sentinel Controlled Loops\n",
        "\n",
        "The first example of while loop was a counter controlled loop as it runs while a counter reaches a certain value.\n",
        "\n",
        "The following example is a sentinel controlled loop, which until a variable does take in a certain value.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "-LvgaKYarDGw",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sum = 0                                                          #initialising sum to 0\n",
        "\n",
        "print(\"Enter the numbers to be summed, enter -1 to exit\")\n",
        "digit = int(input())                                             #explicit conversion of input from character to int \n",
        "\n",
        "while(digit != -1):                                              #test condition\n",
        "  sum = sum+digit                                                #summation of all numbers\n",
        "  digit = int(input())                                           #inputting numbers until user enters -1\n",
        "    \n",
        "print(sum)                                                     #printing final sum"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "MgG02IAprDGx"
      },
      "cell_type": "markdown",
      "source": [
        "### Q3. Write a loop to print all the numbers below 100 that are divisible by 2 and 3. "
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "4zJpOqymyQ41",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "PzvPyJ1SrDGy"
      },
      "cell_type": "markdown",
      "source": [
        "The `len()` function returns the length of a string."
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "lZLzPRzbrDG1"
      },
      "cell_type": "markdown",
      "source": [
        "## Break/Pass/Continue\n",
        "\n",
        "Used to `break`, `pass` or `continue` in a block of code. A block of code is defined by its indentation.\n",
        "\n",
        "### Break \n",
        "The `break` statement terminates the loop containing it. Control of the program flows to the statement immediately after the body of the loop.\n",
        "\n",
        "### Continue\n",
        "The `continue` statement in Python returns the control to the beginning of the current loop. When encountered, the loop starts next iteration without executing the remaining statements in the current iteration.\n",
        "\n",
        "### Pass\n",
        "`pass` is used when a statement is required syntactically but you do not want any command or code to execute.\n",
        "The `pass` statement is a null operation; nothing happens when it executes. \n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "cc-y0VrjrDG1",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "number = 10                       #initialising number\n",
        "\n",
        "while number > 0:                 #test condition\n",
        "  print(number)\n",
        "  number = number-1               #updation\n",
        "  if(number < 5):                 \n",
        "    break                       #breaking out of the loop if number<5\n",
        "  else:\n",
        "    continue                    #continue executing loop if number>=5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "lf3rf1go7NEk"
      },
      "cell_type": "markdown",
      "source": [
        "**Infinite Loop**"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "2qA-AFXvrDG0",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "number = 0                         #initialising\n",
        "while number >= 0:                 #test condition will always be true\n",
        "    print(number)\n",
        "    number += 1                    #updation will never allow test condition to be false\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "OH4R2O768jPD"
      },
      "cell_type": "markdown",
      "source": [
        "It is important to make sure that proper test conditions and updation statements are used."
      ]
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "JdsIRRbErDG3"
      },
      "cell_type": "markdown",
      "source": [
        "### Q4. Add all user inputs until sum is lesser than 50. "
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "q0g0_xHuySAG",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "wVSwMrLcrDGy"
      },
      "cell_type": "markdown",
      "source": [
        "### String Indexing\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1FFLf9Do3w5b9CurQ0VCRo5xz9070ZzwP)"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "H0DCLEkmrDGy",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sum_vowels = 0                                                                                #initialsing sum_vowels\n",
        "print(\"Enter a word to count consonants and vowels\")\n",
        "word = input()                                                                                #inputting a word\n",
        "for i in range(0, len(word)):                                                               #range includes 0,1,2,3,4...till length of word\n",
        "    if(word[i] == 'a' or word[i] == 'e' or word[i] == 'i' or word[i] == 'o' or word[i] == 'u'):           #checking if a character is a vowel \n",
        "        sum_vowels += 1                                                                       #increasing the vowel count\n",
        "    else:\n",
        "        pass\n",
        "print(sum_vowels)                                                                           #printing final sum of vowels"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "rNg-HD8vrDG3"
      },
      "cell_type": "markdown",
      "source": [
        "# Range Function\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1lm0ZE_7gZ9ymHFzIMA674QcdBJ-YuvFM)\n",
        "Default Step is 1."
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "LAT2LUyarDG3",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"python\"\n",
        "for i in range(0, len(string)):\n",
        "    print(string[i])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "_ztqfNRxrDG5",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"python\"\n",
        "for i in range(0, len(string), 2):\n",
        "    print(string[i])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "2Ug1QMXErDG7"
      },
      "cell_type": "markdown",
      "source": [
        "## Nested Loops\n",
        "\n",
        "Python programming language allows to use one loop inside another loop. "
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "JWSlf3sjrDG7",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for number1 in range(0,3):                                          #loop1-range includes 0,1,2\n",
        "  for number2 in range(4,6):                                        #loop2- range includes 4,5 running for every value of loop1\n",
        "    print(\"number1 is \\n\", number1)\n",
        "    print(\"number2 is \\n\", number2)\n",
        "    print(\"number1+number2 = \\n\", number1+number2)\n",
        "    print(\"\\n\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "11tnaUJ5rDG9"
      },
      "cell_type": "markdown",
      "source": [
        "### Q5. Write a loop to print the first 100 prime numbers. "
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "1P-Uc7asyPBI",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "xeYuXIVCrDG9"
      },
      "cell_type": "markdown",
      "source": [
        "# Strings\n",
        "\n",
        "## Basic String Functions\n",
        "\n",
        "![alt text](https://drive.google.com/uc?export=view&id=1DzpNp_MMhWXT5g3s9ECH1Z_GcAKAlJrI)\n",
        "\n",
        "## String Slicing in Python \n",
        "\n",
        "Different methods of obtaining a Sub-string from a string.\n",
        "\n",
        "-  a[start:stop]  # items start through stop-1\n",
        "\n",
        "-  a[start:]      # items start through the rest of the string\n",
        "\n",
        "-  a[:stop]       # items from the beginning through stop-1\n",
        "\n",
        "-  a[:]           # a copy of the whole string\n",
        "\n",
        "There is also the step value, which can be used with any of the above:\n",
        "\n",
        "-  a[start:stop:step] # start through not past stop, by step"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "4AU9RfUTrDG9",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"scrumptious\"\n",
        "new_string = string[3:8]\n",
        "\n",
        "print(new_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "-zs3V6jIrDG-",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"scrumptious\"\n",
        "new_string = string[1:]\n",
        "\n",
        "print(new_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ux4R5YU_rDHA",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"scrumptious\"\n",
        "new_string = string[-4:-9:-1]\n",
        "\n",
        "print(new_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "02Tlm_durDHB",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"scrumptious\"\n",
        "new_string = string[::-1]\n",
        "\n",
        "print(new_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "8vtcZzo6rDHC",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"python\"\n",
        "\n",
        "print(len(string))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "svD67KO6rDHD"
      },
      "cell_type": "markdown",
      "source": [
        "### Q6. Count the number of uppercase and lowercase characters in a string"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "QveuJTdu0bmA",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "cvADFLhhrDHD"
      },
      "cell_type": "markdown",
      "source": [
        "## String Concatenation using '+' operator\n",
        "\n",
        "Used to make a new string by putting together two separate strings end to end"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "6p6cwwrErDHE",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string1 = \"hey\"\n",
        "string2 = \"there\"\n",
        "string_final = string1+string2\n",
        "\n",
        "print(string_final)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ncWCkhQ1rDHF",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "string = \"nom\"\n",
        "\n",
        "print(string*10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "Pc9yVJI4rDHG",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "a = input(\"Enter a character to find ASCII value \\n\")\n",
        "\n",
        "print(\"The ASCII value of the entered number is\\n\",ord('a'))                                                "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "ra5ugjXsrDHG",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "number = int(input(\" Enter an ASCII value to find character \\n\"))\n",
        "\n",
        "print(\"The corresponding character of the input ASCII value is\\n\",chr(number))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "3lDUKki1rDHI"
      },
      "cell_type": "markdown",
      "source": [
        "### Q7. Find if a word is a palindrome.  \n",
        "Palindrome is defined as a String which when read from either direction does not change. \n",
        "eg: \n",
        "+ Anna\n",
        "+ Civic\n",
        "+ Kayak\n",
        "+ Level\n",
        "+ Madam\n",
        "+ Racecar\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "SXJVCTGQrDHI",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#write your code here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "KtXa6cJ25Sq8"
      },
      "cell_type": "markdown",
      "source": [
        "# Importing External Libraries\n",
        "\n",
        "\n",
        "Python modules can get access to code from another module by importing the file/function using `import`\n",
        "\n",
        "This allows the user to use pre-defined functions and modules in his/her code directly without having to write the entire thing again.\n"
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "4kt9avJnA70c",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "print(math.sqrt(4))                         #sqrt()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "colab_type": "text",
        "id": "hm1LoVnYBhV_"
      },
      "cell_type": "markdown",
      "source": [
        "You can further explore the other modules in the Math library at https://docs.python.org/3/library/math.html"
      ]
    }
  ]
}