Introduction_to_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Introduction to Python",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ialimustufa/python-crash-course/blob/master/Introduction_to_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ei-GOj0Gu-9S",
        "colab_type": "text"
      },
      "source": [
        "#Introduction to Colab for the classroom\n",
        "\n",
        "This is an \"Google Colab\" notebook. It's a shared document where everybody can see and make changes to the same document.\n",
        "\n",
        "The first few problems will get us acquainted with working together;\n",
        "\n",
        "1.Go to file in the upper left corner\n",
        "\n",
        "2.Click Save copy in drive\n",
        "\n",
        "3.Follow along and use your own notebook!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1D9tQyRbuQwg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# This is a comment\n",
        "# in a code cell\n",
        "# Press shift + enter to execute a cell\n",
        "# Nothing will print from this cell since these are all comments"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TjZmYl523lH",
        "colab_type": "text"
      },
      "source": [
        "# **What is Python?**\n",
        "\n",
        "Python is an open-source object-oriented programming language. It first \n",
        "appeared in 1991 and has become extremely popular among data scientists. StackOverflow calls it as the fastest growing programming language.\n",
        "\n",
        "It is used for:\n",
        "\n",
        "*   Web development\n",
        "*   Software Development\n",
        "*   Mathematics\n",
        "*   System Scripting and Much more\n",
        "\n",
        "\n",
        "# **What Python can 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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jj2dwPJGxZDy",
        "colab_type": "text"
      },
      "source": [
        "# Why Learn Python?\n",
        "Python’s syntax is very simple hence it's easy for the beginners to understand. The lines of code required for a task is less compared to other languages.\n",
        "\n",
        "\n",
        "*  Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).\n",
        "* Python has a simple syntax similar to the English language.\n",
        "* Python has syntax that allows developers to write programs with fewer lines than some other programming languages.\n",
        "*  Python runs on an interpreter system, meaning that code can be executed as soon as it is written. This means that prototyping can be very quick.\n",
        "*  Python can be treated in a procedural way, an object-orientated way or a functional way."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XnoczNYXz1TI",
        "colab_type": "text"
      },
      "source": [
        "# **Let’s look at some cool features of Python:**\n",
        "\n",
        "1.   Simple and easy to learn\n",
        "2.   Free and Open Source\n",
        "3.   Portable\n",
        "4.   Supports different programming paradigm\n",
        "5.   Extensible"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjwVKXvB0VKw",
        "colab_type": "text"
      },
      "source": [
        "# **Python Applications:**\n",
        "​\n",
        "1.    Artificial Intelligence\n",
        "2.    Desktop Application\n",
        "3.    Automation\n",
        "4.    Web Development\n",
        "5.    Data Wrangling, Exploration\n",
        "6.    Visualization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "huR1RLMp1FgR",
        "colab_type": "text"
      },
      "source": [
        "# **Python Setup:**\n",
        "\n",
        "For Windows PC, search in the start bar for Python or run the following on the Command Line (cmd.exe):\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python --version\n",
        "```\n",
        "\n",
        "To check if you have python installed on a Linux or Mac, then on linux open the command line or on Mac open the Terminal and type:\n",
        "\n",
        "```\n",
        "python --version\n",
        "```\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "*   If you are on Windows OS download Python by [clicking here](https://www.python.org/downloads/windows/) and now install from the setup and in the start menu type IDLE.IDLE, you can think it as an Python’s IDE to run the Python Scripts.\n",
        "*  If you are on Linux/Unix-like just open the terminal and on 99% linux OS Python comes preinstalled with the OS.Just type ‘python3’ in terminal and you are ready to go.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cc1FDi8M26vh",
        "colab_type": "text"
      },
      "source": [
        "# **Starting with Python**\n",
        "\n",
        "Python is an interpreted programming language, this means that as a developer you write Python (.py) files in a text editor and then put those files into the python interpreter to be executed.\n",
        "\n",
        "The way to run a python file is like this on the command line:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python helloworld.py\n",
        "```\n",
        "Where \"helloworld.py\" is the name of your python file.\n",
        "\n",
        "Let's write our first Python file, called helloworld.py, which can be done in any text editor.\n",
        "\n",
        "\n",
        "helloworld.py\n",
        "```\n",
        "print(\"Hello, World! :) \")\n",
        "```\n",
        "Simple as that. Save your file. Open your command line, navigate to the directory where you saved your file, and run:\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python helloworld.py\n",
        "```\n",
        "\n",
        "The output should read:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Hello, World! :)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qViu26SV6-TK",
        "colab_type": "text"
      },
      "source": [
        "# **Python Syntax & Indentation**\n",
        "\n",
        "Python syntax can be executed by writing directly in the Command Line:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        ">>> print(\"Hello, World! :)\")\n",
        "Hello, World! :)\n",
        "```\n",
        "\n",
        "Or by creating a python file on the server, using the .py file extension, and running it in the Command Line:\n",
        "\n",
        "```\n",
        "C:\\Users\\Your Name>python myfile.py\n",
        "```\n",
        "\n",
        "\n",
        "**Python Indentation**\n",
        "\n",
        "\n",
        "Indentation refers to the spaces at the beginning of a code line.\n",
        "\n",
        "Where in other programming languages the indentation in code is for readability only, the indentation in Python is very important.\n",
        "\n",
        "Python uses indentation to indicate a block of code.\n",
        "\n",
        "Example :\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eR0pjRyn7Tta",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        },
        "outputId": "a63f7475-4f20-4e1d-b9ba-b5845cfd3bbd"
      },
      "source": [
        "if 5 > 2:\n",
        "print(\"Five is greater than two!\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-a314491c53bb>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(\"Five is greater than two!\")\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k0xS4nZX9Y04",
        "colab_type": "text"
      },
      "source": [
        "The number of spaces is up to you as a programmer, but it has to be at least one."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zq9-XLgz9cZ_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "25f5686b-b6e7-4786-dd51-840e229ed9ed"
      },
      "source": [
        "if 10 > 5:\n",
        " print(\"Ten is greater than Five!\") \n",
        "if 10 > 5:\n",
        "        print(\"Ten is greater than Five!\") \n",
        "        print(\"Ten is greater than Five!\") "
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ten is greater than Five!\n",
            "Ten is greater than Five!\n",
            "Ten is greater than Five!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "btd_GvHt9upn",
        "colab_type": "text"
      },
      "source": [
        "# **Comments:**\n",
        "\n",
        "Python has commenting capability for the purpose of in-code documentation.\n",
        "\n",
        "Comments start with a #, and Python will render the rest of the line as a comment:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a_YeED9D9x6s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "750ea6f9-2874-49de-912c-ea63d8b77013"
      },
      "source": [
        "#This is a comment, this line will not execute.\n",
        "print(\"Yoooo!\")"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yoooo!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pft3WfTe-LUe",
        "colab_type": "text"
      },
      "source": [
        "*   Comments can be used to explain Python code.\n",
        "\n",
        "*   Comments can be used to make the code more readable.\n",
        "*   Comments can be used to prevent execution when testing code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wNrzNU5mC4W0",
        "colab_type": "text"
      },
      "source": [
        "**Multi Line Comments**\n",
        "\n",
        "You can add a multiline string (triple quotes) in your code, and place your comment inside it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fOW3Pgt5-fc8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "553687bd-02ff-4951-dd09-9cbb39c28747"
      },
      "source": [
        "\"\"\"\n",
        "This is a comment\n",
        "written in\n",
        "more than just one line\n",
        "\"\"\"\n",
        "print(\"Hello, World! :)\")"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World! :)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MiCtOU0F-uLN",
        "colab_type": "text"
      },
      "source": [
        "# **Variables in Python:**\n",
        "\n",
        "Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.\n",
        "\n",
        "In Python you don’t need to declare variables before using it, unlike other languages like Java, C etc.\n",
        "\n",
        "# **Assigning values to a variable:**\n",
        "\n",
        "Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. \n",
        "The equal sign (=) is used to assign values to variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WOgTcEk2_J21",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "448c8eff-cd3b-4e4c-acfb-ba7208c9077a"
      },
      "source": [
        "x = 11\n",
        "y = \"Google\"\n",
        "print(x)\n",
        "print(y)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n",
            "Google\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RlM5twW_VQB",
        "colab_type": "text"
      },
      "source": [
        "Variables do not need to be declared with any particular type and can even change type after they have been set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fo-8MR7q_b-o",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "96a12289-3297-4395-9e8c-ab9acfe92484"
      },
      "source": [
        "x = 4 # x is of type int\n",
        "x = \"Frost forbite\" # x is now of type str\n",
        "print(x)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Frost forbite\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N09PcvZvFPt9",
        "colab_type": "text"
      },
      "source": [
        "String variables can be declared either by using single or double quotes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGG7Pza5FQzg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = \"Marcus Burns\"\n",
        "# is the same as\n",
        "x = 'Marcus Burns'"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SR0saT9KvwE",
        "colab_type": "text"
      },
      "source": [
        "# **Assign Value to Multiple Variables:**\n",
        "\n",
        "Python allows you to assign values to multiple variables in one line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tTsMoY7MK1wx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "8730664d-7b1a-4dcb-d3ac-f680384b3c77"
      },
      "source": [
        "x, y, z = \"Apples\", \"Grapes\", \"Mangoes\"\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Apples\n",
            "Grapes\n",
            "Mangoes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TyJ-roCOK9zT",
        "colab_type": "text"
      },
      "source": [
        "And you can assign the same value to multiple variables in one line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AC-SxzcVK_6J",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "d0b5fb1c-c1da-4c8f-f019-d6bc8312c1cf"
      },
      "source": [
        "x = y = z = \"Kiwi\"\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Kiwi\n",
            "Kiwi\n",
            "Kiwi\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CiqSG-_tLQDR",
        "colab_type": "text"
      },
      "source": [
        "# **Assign Value to Multiple Variables:**\n",
        "\n",
        "The Python print statement is often used to output variables.\n",
        "\n",
        "To combine both text and a variable, Python uses the + character:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ULO5y2EOLS8J",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "7d5eb0fb-9b33-47ec-89f7-ad0c0b19c088"
      },
      "source": [
        "x = \"amazing!\"\n",
        "print(\"You are \" + x)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You are amazing!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FzVHp-HhORrv",
        "colab_type": "text"
      },
      "source": [
        "You can also use the + character to add a variable to another variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MnHDOMNzOVWd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "7faf6a5f-5615-4889-e59a-19daa26aa179"
      },
      "source": [
        "x = \"You're \"\n",
        "y = \"awesome!\"\n",
        "z =  x + y\n",
        "print(z)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You're awesome!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aMb4ewOgOb8I",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "For numbers, the + character works as a mathematical operator:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u6MSflGbOhOw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "eab438a7-a1d0-4ddd-fa7f-eba7f20a268f"
      },
      "source": [
        "x = 20\n",
        "y = 10\n",
        "print(x + y)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "30\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pULZk2i3OpH8",
        "colab_type": "text"
      },
      "source": [
        "# **Data Types in Python:**\n",
        "Python supports various data types, these data types defines the operations possible on the variables and the storage method. \n",
        "\n",
        "\n",
        "* Text Type:\t`str`\n",
        "* Numeric Types:\t`int, float, complex`\n",
        "* Sequence Types:\t`list, tuple, range`\n",
        "* Mapping Type:\t`dict`\n",
        "* Set Types:\t`set, frozenset`\n",
        "* Boolean Type:\t`bool`\n",
        "* Binary Types:\t`bytes, bytearray, memoryview`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QVlmz3KzOvEv",
        "colab_type": "text"
      },
      "source": [
        "# **Getting the Data Type:**\n",
        "\n",
        "You can get the data type of any object by using the type() function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZN5P37qLOwYW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "be6c07e0-ee1d-4d4b-d94c-93febd9340b1"
      },
      "source": [
        "x = 5\n",
        "print(type(x))"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JmJ0drEEO7Sp",
        "colab_type": "text"
      },
      "source": [
        "**Numeric:**\n",
        "\n",
        "Just as expected Numeric data types store numeric values. They are immutable data types, this means that you cannot change it’s value. Python supports three different Numeric data types:\n",
        "\n",
        "1. Integer type: It holds all the integer values i.e. all the positive and negative whole numbers, example – 10.\n",
        "\n",
        "2. Float type: It holds the real numbers and are represented by decimal and sometimes even scientific notations with E or e indicating the power of 10 (2.5e2 = 2.5 x 102 = 250), example – 10.24.\n",
        "\n",
        "3. Complex type: These are of the form a + bj, where a and b are floats and J represents the square root of -1 (which is an imaginary number), example – 10+6j.\n",
        "\n",
        "Now you can even perform type conversion. For example, you can convert the integer value to a float value and vice-versa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "860P3--YPFvM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "55f98dc8-646f-4f19-b0f1-b7b0545d824b"
      },
      "source": [
        "x = 11    # int\n",
        "y = 2.8  # float\n",
        "z = 3+1j   # complex\n",
        "\n",
        "print(type(x))\n",
        "print(type(y))\n",
        "print(type(z))"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'complex'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tMCB-d5SPPcz",
        "colab_type": "text"
      },
      "source": [
        "**Type Conversion**\n",
        "\n",
        "You can convert from one type to another with the int(), float(), and complex() methods:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7SPYqyfwPQoj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "559349da-df07-423c-d93d-7c7cc2b4879c"
      },
      "source": [
        "a = 101\n",
        "# Convert it into float type\n",
        "b = float(a)\n",
        "print(b)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "101.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLEAczK2Pf3_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "fb2eb2aa-6ed1-4cb3-ecb6-78ee1611e7ba"
      },
      "source": [
        "a = 8.16\n",
        "# Convert it into int type\n",
        "b = int(a)\n",
        "print(b)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uevK81TSPqiU",
        "colab_type": "text"
      },
      "source": [
        "**Strings:**\n",
        "\n",
        "Strings are amongst the most popular data types in Python. We can create them simply by enclosing characters in quotes. Python treats single and double quotes in exactly the same fashion. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PFRQnE8vPswE",
        "colab_type": "text"
      },
      "source": [
        "**String Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on strings.\n",
        "\n",
        "* capitalize() : Converts the first character to upper case\n",
        "* casefold() :\tConverts string into lower case\n",
        "* count() :\tReturns the number of times a specified value occurs in a string\n",
        "* encode()\t: Returns an encoded version of the string\n",
        "* find() :\tSearches the string for a specified value and returns the position of where it was found\n",
        "* format() :\tFormats specified values in a string\n",
        "* index()\t: Searches the string for a specified value and returns the position of where it was found\n",
        "* isdecimal() :\tReturns True if all characters in the string are decimals\n",
        "* isdigit() :\tReturns True if all characters in the string are digits\n",
        "* isidentifier() :\tReturns True if the string is an identifier\n",
        "* islower()\t: Returns True if all characters in the string are lower case\n",
        "* isnumeric()\t: Returns True if all characters in the string are numeric\n",
        "* isupper()\t: Returns True if all characters in the string are upper case\n",
        "* lower() :\tConverts a string into lower case\n",
        "* upper()\t: Converts a string into upper case"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "URny1DMeQEUF",
        "colab_type": "text"
      },
      "source": [
        "**Strings are Arrays**\n",
        "\n",
        "Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
        "\n",
        "However, Python does not have a character data type, a single character is simply a string with a length of 1.\n",
        "\n",
        "Square brackets can be used to access elements of the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d32_CS-LQLO9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "2df018a4-f5f1-4a86-f1ca-86cc53d5e612"
      },
      "source": [
        "#Get the character at position 1 (remember that the first character has the position 0):\n",
        "\n",
        "a = \"Hello, World!\"\n",
        "print(a[1])"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J3T1vjztQhRo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        },
        "outputId": "61335e11-0477-4244-a6d7-7ddbcd131ecc"
      },
      "source": [
        "a = \"Hello World!\"\n",
        "b = 'Welcome'\n",
        "\n",
        "#operations on Strings-*\n",
        "\n",
        "print (len(b))\t        #String Length\n",
        "print (a.index('e'))    #Locate a character in String\n",
        "print (a.count('l'))\t  #Count the number of times a character is repeated in a String\n",
        "print (a[1:5])\t        #Slicing\n",
        "print (a[::-1])\t        #Reverse a String\n",
        "print (b.upper())\t      #Convert the letters in a String to upper-case\n",
        "print (b.lower())       #Convert the letters in a String to lower-case"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "1\n",
            "3\n",
            "ello\n",
            "!dlroW olleH\n",
            "WELCOME\n",
            "welcome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KWC2_vcGRCig",
        "colab_type": "text"
      },
      "source": [
        "**List:**\n",
        "\n",
        "You can consider the Lists as Arrays in C, but in List you can store elements of different types, but in Array all the elements should of the same type.\n",
        "List is the most versatile datatype available in Python which can be written as a list of comma-separated values (items) between square brackets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZjaRi7jRHxs",
        "colab_type": "text"
      },
      "source": [
        "**List Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on lists.\n",
        "\n",
        "\n",
        "* append() : Adds an element at the end of the list\n",
        "* clear()\t: Removes all the elements from the list\n",
        "* copy() :\tReturns a copy of the list\n",
        "* count() :\tReturns the number of elements with the specified value\n",
        "* extend(): Add the elements of a list (or any iterable), to the end of the current list\n",
        "* index()\t: Returns the index of the first element with the specified value\n",
        "* insert() :\tAdds an element at the specified position\n",
        "* pop() :\tRemoves the element at the specified position\n",
        "* remove() :\tRemoves the item with the specified value\n",
        "* reverse() :\tReverses the order of the list\n",
        "* sort() :\tSorts the list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0XmYBMyGRS62",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        },
        "outputId": "264d3f8c-88a2-43e9-ac86-4e0689615ae1"
      },
      "source": [
        "Sports = ['Basketball', 'Cricket', 'Football', 1,5,6.0]\n",
        "print(Sports)\n",
        "\n",
        "#operations on lists\n",
        "\n",
        "print (Sports[0])       #printing the value at index\n",
        "print (Sports[0:3])     #slicing the values in the List\n",
        "Sports[2]='Rugby'       #replacing the value at particular index\n",
        "print (Sports[2])\n",
        "del Sports[1]           #deleting a value at an index \n",
        "print (Sports)\n",
        "print (len(Sports))     #get the length of the string\n",
        "print (Sports*2)\n",
        "\n"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Basketball', 'Cricket', 'Football', 1, 5, 6.0]\n",
            "Basketball\n",
            "['Basketball', 'Cricket', 'Football']\n",
            "Rugby\n",
            "['Basketball', 'Rugby', 1, 5, 6.0]\n",
            "5\n",
            "['Basketball', 'Rugby', 1, 5, 6.0, 'Basketball', 'Rugby', 1, 5, 6.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zee3cqulS5t-",
        "colab_type": "text"
      },
      "source": [
        "**Tuples:**\n",
        "\n",
        "A Tuple is a sequence of immutable Python objects. Tuples are sequences, just like Lists. The differences between tuples and lists are:\n",
        "\n",
        "\n",
        "\n",
        "*   Tuples cannot be changed unlike lists\n",
        "*   Tuples use parentheses, whereas lists use square brackets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QS6W9GjLS9-d",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "18a33288-88c0-4af2-edaf-bdddc7f0d384"
      },
      "source": [
        "Datatypes = ('Numeric', 'List', 'Tuples')\n",
        "print (Datatypes)\n"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('Numeric', 'List', 'Tuples')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8lTMliwTZYa",
        "colab_type": "text"
      },
      "source": [
        "**Negative Indexing**\n",
        "\n",
        "Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second last item etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IM25puDcTaxu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "88ee09ca-f11a-4147-b55f-9a94d6fff923"
      },
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
        "print(thistuple[-1])"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cherry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSKtUe83TpKF",
        "colab_type": "text"
      },
      "source": [
        "**Range of Indexes**\n",
        "\n",
        "You can specify a range of indexes by specifying where to start and where to end the range.\n",
        "\n",
        "When specifying a range, the return value will be a new tuple with the specified items."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SkSnMdsCTwyG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "3182f1a0-f4dc-4b0d-d97b-1bf178ef85c1"
      },
      "source": [
        "thistuple = (\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\")\n",
        "print(thistuple[2:5])"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('cherry', 'orange', 'kiwi')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mwhRYU5UUWDL",
        "colab_type": "text"
      },
      "source": [
        "**Tuple Methods**\n",
        "\n",
        "Python has two built-in methods that you can use on tuples.\n",
        "\n",
        "* count()\t: Returns the number of times a specified value occurs in a tuple\n",
        "* index()\t: Searches the tuple for a specified value and returns the position of where it was found"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NcdqnKdRUt-0",
        "colab_type": "text"
      },
      "source": [
        "**Set:**\n",
        "\n",
        "A Set is an unordered collection of items. Every element is unique.\n",
        "A Set is created by placing all the items (elements) inside curly braces {}, separated by comma. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z9PH4XAXUxS_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 100
        },
        "outputId": "7e5b1ec8-bf20-4e60-8c8a-daa685d06f07"
      },
      "source": [
        "Set1 = {1, 2, 3}\n",
        "print (Set1)\n",
        "Set2 = {4, 5, 5, 6}\n",
        "print (Set2)\n",
        "\n",
        "#set opreations\n",
        "\n",
        "A = {1, 2, 3, 4}\n",
        "B = {3, 4, 5, 6}\n",
        "print ( A | B)      #union\n",
        "print ( A & B )     #intersection\n",
        "print(A - B)        #difference"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{1, 2, 3}\n",
            "{4, 5, 6}\n",
            "{1, 2, 3, 4, 5, 6}\n",
            "{3, 4}\n",
            "{1, 2}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BG33LT1jWVxD",
        "colab_type": "text"
      },
      "source": [
        "**Dictionary Methods**\n",
        "\n",
        "Python has a set of built-in methods that you can use on dictionaries.\n",
        "\n",
        "* clear() :\tRemoves all the elements from the dictionary\n",
        "* copy()\t: Returns a copy of the dictionary\n",
        "* get()\t: Returns the value of the specified key\n",
        "* items()\t: Returns a list containing a tuple for each key value pair\n",
        "* keys()\t: Returns a list containing the dictionary's keys\n",
        "* pop()\t: Removes the element with the specified key\n",
        "* popitem() :\tRemoves the last inserted key-value pair\n",
        "* update() :\tUpdates the dictionary with the specified key-value pairs\n",
        "* values() :\tReturns a list of all the values in the dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XBVUOI6mWbW5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "06cb6730-389c-4013-83e6-0058c5c6f312"
      },
      "source": [
        "family = {\n",
        "  \"child1\" : {\n",
        "    \"name\" : \"Walter White\",\n",
        "    \"year\" : 2004\n",
        "  },\n",
        "  \"child2\" : {\n",
        "    \"name\" : \"Jesse Pinkman\",\n",
        "    \"year\" : 2007\n",
        "  },\n",
        "  \"child3\" : {\n",
        "    \"name\" : \"Harvey Specter\",\n",
        "    \"year\" : 2011\n",
        "  }\n",
        "}\n",
        "print (family)\n",
        "\n"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'child1': {'name': 'Walter White', 'year': 2004}, 'child2': {'name': 'Jesse Pinkman', 'year': 2007}, 'child3': {'name': 'Harvey Specter', 'year': 2011}}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tvslFLCWZ1bH",
        "colab_type": "text"
      },
      "source": [
        "Operators in Python:\n",
        "\n",
        "Operators are the constructs which can manipulate the values of the operands. Consider the expression 2 + 3 = 5, here 2 and 3 are operands and + is called operator.\n",
        "\n",
        "*Types of Operators in Python: *\n",
        "\n",
        "Arithmetic\n",
        "\n",
        "Comparision\n",
        "\n",
        "Logical\n",
        "\n",
        "Assignment\n",
        "\n",
        "Bitwise"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RIeUyG_4Z__-",
        "colab_type": "text"
      },
      "source": [
        "Arithmetic Operation:\n",
        "\n",
        "These Operators are used to perform mathematical operations like addition, subtraction etc.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cSkXbDXiaCJ2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 117
        },
        "outputId": "998ea758-61e7-4381-a8e9-4664cf4123ff"
      },
      "source": [
        "a = 11\n",
        "b = 20\n",
        "c = 0\n",
        " \n",
        "c = a + b\n",
        "print ( c )\n",
        " \n",
        "c = a - b\n",
        "print ( c )\n",
        " \n",
        "c = a * b\n",
        "print ( c )\n",
        " \n",
        "c = a / b\n",
        "print ( c )\n",
        " \n",
        "c = b % a\n",
        "print ( c )\n",
        "\n",
        "a = 2\n",
        "b = 3\n",
        "c = a ** b\n",
        "print ( c )"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "31\n",
            "-9\n",
            "220\n",
            "0.55\n",
            "9\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UiO2-g1laJrO",
        "colab_type": "text"
      },
      "source": [
        "Comparision Operation:\n",
        "\n",
        "These Operators compare the values on either sides of them and decide the relation among them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_RKwhzvWaNRu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 117
        },
        "outputId": "fa210382-cc30-4838-f666-c336759b41b8"
      },
      "source": [
        "a = 11\n",
        "b = 20\n",
        "result = (a == b)\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = (a != b)\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = ( a < b )\n",
        "\n",
        "print(result)\n",
        " \n",
        "result = ( a > b )\n",
        "\n",
        "print(result)\n",
        "\n",
        "result = ( a <= b )\n",
        "\n",
        "print(result)\n",
        "\n",
        "type(result)\n"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oXcDjDAAsHsh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 33
        },
        "outputId": "d668fdc3-70c9-442c-de2e-2fcb30f83fde"
      },
      "source": [
        "result = ( a >= b)\n",
        "result"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTilkmuJYRLR",
        "colab_type": "text"
      },
      "source": [
        "# Logical Operators\n",
        "* ( and ) to check if the LHS and RHS conditions both conditions are satisfied. Basically checking for truthy values\n",
        "* ( or  ) to check if atleast one of the side satisfy the condition. Basically checking for truthy values\n",
        "* ( not ) to check if the condition is not satified. Basically checking for falsy values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yktGQJDnaVtv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "5d185f5f-4faa-4fc8-9902-b131e01b946b"
      },
      "source": [
        "x = True\n",
        "y = False\n",
        " \n",
        "print('x and y is',x and y)\n",
        " \n",
        "print('x or y is',x or y)\n",
        " \n",
        "print('not x is',not x)"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x and y is False\n",
            "x or y is True\n",
            "not x is False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1E1lQlM6YZEn",
        "colab_type": "text"
      },
      "source": [
        "# **Input Output:**\n",
        "Take input from the user and work with it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XNUhYjMwegiX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "5df88946-3872-41b1-9392-9d58b79be435"
      },
      "source": [
        "my_age = input(\"Enter your age: \")\n",
        "\n",
        "add_age = my_age + 2 #It will throw an error\n",
        "\n",
        "#lets check why?\n",
        "type(my_age)\n",
        "\n",
        "#Lets fix this;\n",
        "\n"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter your age: 10\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "astaY2wWuCZM",
        "colab_type": "text"
      },
      "source": [
        "Bitwise Operators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-kFgNadkuB_S",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "ff494818-315e-4a37-ca91-25fc5a684ec3"
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "\n",
        "#0001\n",
        "#0010\n",
        "\n",
        "# OR Operator |\n",
        "\n",
        "print(a | b)\n",
        "# 0011\n",
        "\n",
        "# and operator &\n",
        "print(a & b)\n",
        "#0000\n",
        "\n",
        "# XOR operator\n",
        "print(a ^ b)"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "0\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ycdHU0kBvVxY",
        "colab_type": "text"
      },
      "source": [
        "Assignment operators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S9NKUi70vYWm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# =\n",
        "c = 1\n",
        "a = 2\n",
        "b = 3\n",
        "#c = a + b\n",
        "#c = c + a + b\n",
        "\n",
        "# c += a\n",
        "# print(c)\n",
        "\n",
        "# -= subtract your value and assign it\n",
        "\n",
        "# c -= a\n",
        "# c - a\n",
        "# c = c - a\n",
        "# print(c)\n",
        "\n",
        "# *= multiplication assignment operator\n",
        "# c *= a\n",
        "# print(c)\n",
        "\n",
        "# /= division assignment operator\n",
        "# c /= a\n",
        "# print(c)\n",
        "\n",
        "# //= floor division assignment operator\n",
        "\n",
        "# a //= c\n",
        "#  c / a\n",
        " # 0.5 floor\n",
        " # 0\n",
        "#  c = 0\n",
        "# print(c)\n",
        "\n",
        "# **= power assignment operator\n",
        "\n",
        "# a **= b\n",
        "# print(a)"
      ],
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tRGAaBYocSF8",
        "colab_type": "text"
      },
      "source": [
        "# HW\n",
        "\n",
        "WAP to create a basic data collection system using python where: \n",
        "* It takes username, password and age from input.\n",
        "* It must store atleast 2 user information taken from input.\n",
        "* After that, it should display the name, total age and avg.\n",
        "* Atleast 1 of the datastructures should be used.\n",
        "* You are allowed to use more than one code block\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a8jl4juoy-2o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Sample Output:\n",
        "\n",
        "# enter details for user1\n",
        "# Name: Ali\n",
        "# Password: admin\n",
        "# Age: 23\n",
        "\n",
        "# enter details for user2\n",
        "# Name: Ram\n",
        "# Password: admin\n",
        "# Age: 25\n",
        "\n",
        "# Users: Ali and Ram\n",
        "#Total Age = 48\n",
        "#Avg Age = 24\n",
        "\n"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjuPYlcqzPiz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}