Session_1_1_Python_Installation_and_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.1"
    },
    "colab": {
      "name": "Session 1.1 - Python-Installation and Basics.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/plaban1981/INEURON/blob/master/Session_1_1_Python_Installation_and_Basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53TGHgNAXapf",
        "colab_type": "text"
      },
      "source": [
        "## Introduction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5FK6AwfXapj",
        "colab_type": "text"
      },
      "source": [
        "Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse. The Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s6m5dKwFXapk",
        "colab_type": "text"
      },
      "source": [
        "erwtsdfpkewrijfjiopjgpoisgsf\n",
        "sdfgodgfjdfg\n",
        "fgdflgjdfg\n",
        "gdfkgjhdfkgd\n",
        "kbdfg\n",
        "dgdflkghdfg\n",
        "gdfjhg"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73XPAMcvXapm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hV9OdiDAXapq",
        "colab_type": "text"
      },
      "source": [
        "Python is a great general-purpose programming language on its own, but with the help of a few popular libraries (numpy, scipy, matplotlib) it becomes a powerful environment for scientific computing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "868oG5T-Xaps",
        "colab_type": "text"
      },
      "source": [
        "## Python Version\n",
        "### Python 2\n",
        "Published in late 2000, Python 2 signalled a more transparent and inclusive language development process than earlier versions of Python with the implementation of PEP (Python Enhancement Proposal), a technical specification that either provides information to Python community members or describes a new feature of the language.\n",
        "\n",
        "Additionally, Python 2 included many more programmatic features including a cycle-detecting garbage collector to automate memory management, increased Unicode support to standardize characters, and list comprehensions to create a list based on existing lists. As Python 2 continued to develop, more features were added, including unifying Python’s types and classes into one hierarchy in Python version 2.2.\n",
        "\n",
        "\n",
        "### Python 3\n",
        "\n",
        "Python 3 is regarded as the future of Python and is the version of the language that is currently in development. A major overhaul, Python 3 was released in late 2008 to address and amend intrinsic design flaws of previous versions of the language. The focus of Python 3 development was to clean up the codebase and remove redundancy, making it clear that there was only one way to perform a given task.\n",
        "\n",
        "Major modifications to Python 3.0 included changing the print statement into a built-in function, improve the way integers are divided, and providing more Unicode support.\n",
        "\n",
        "At first, Python 3 was slowly adopted due to the language not being backwards compatible with Python 2, requiring people to make a decision as to which version of the language to use. Additionally, many package libraries were only available for Python 2, but as the development team behind Python 3 has reiterated that there is an end of life for Python 2 support, more libraries have been ported to Python 3. The increased adoption of Python 3 can be shown by the number of Python packages that now provide Python 3 support, which at the time of writing includes 339 of the 360 most popular Python packages.\n",
        "\n",
        "### Python 2.7\n",
        "\n",
        "Following the 2008 release of Python 3.0, Python 2.7 was published on July 3, 2010 and planned as the last of the 2.x releases. The intention behind Python 2.7 was to make it easier for Python 2.x users to port features over to Python 3 by providing some measure of compatibility between the two. This compatibility support included enhanced modules for version 2.7 like unittest to support test automation, argparse for parsing command-line options, and more convenient classes in collections.\n",
        "\n",
        "Because of Python 2.7’s unique position as a version in between the earlier iterations of Python 2 and Python 3.0, it has persisted as a very popular choice for programmers due to its compatibility with many robust libraries. When we talk about Python 2 today, we are typically referring to the Python 2.7 release as that is the most frequently used version.\n",
        "\n",
        "Python 2.7, however, is considered to be a legacy language and its continued development, which today mostly consists of bug fixes, will cease completely in 2020.\n",
        "\n",
        "### Key Differences\n",
        "While Python 2.7 and Python 3 share many similar capabilities, they should not be thought of as entirely interchangeable. Though you can write good code and useful programs in either version, it is worth understanding that there will be some considerable differences in code syntax and handling.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "uF06nnyCXapu",
        "colab_type": "text"
      },
      "source": [
        "## Anaconda Python Distribution\n",
        "Anaconda is an open-source package manager, environment manager, and distribution of the Python and R programming languages. It is commonly used for large-scale data processing, scientific computing, and predictive analytics, serving data scientists, developers, business analysts, and those working in DevOps.\n",
        "\n",
        "Anaconda offers a collection of over 720 open-source packages, and is available in both free and paid versions. The Anaconda distribution ships with the conda command-line utility. You can learn more about Anaconda and conda by reading the Anaconda Documentation pages."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F0aji9FvXapw",
        "colab_type": "text"
      },
      "source": [
        "### Why Anaconda?\n",
        "* User level install of the version of python you want\n",
        "* Able to install/update packages completely independent of system libraries or admin privileges\n",
        "* conda tool installs binary packages, rather than requiring compile resources like pip - again, handy if you have limited privileges for installing necessary libraries.\n",
        "* More or less eliminates the headaches of trying to figure out which version/release of package X is compatible with which version/release of package Y, both of which are required for the install of package Z\n",
        "* Comes either in full-meal-deal version, with numpy, scipy, PyQt, spyder IDE, etc. or in minimal / alacarte version (miniconda) where you can install what you want, when you need it\n",
        "* No risk of messing up required system libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BrD8q93QXapx",
        "colab_type": "text"
      },
      "source": [
        "## Installing on Windows\n",
        "\n",
        "1. [Download the Anaconda installer](https://www.continuum.io/downloads).\n",
        "\n",
        "2. Optional: Verify data integrity with MD5 or SHA-256. More info on hashes\n",
        "\n",
        "3. Double click the installer to launch.\n",
        "\n",
        "  NOTE: If you encounter any issues during installation, temporarily disable your anti-virus software during install, then re-enable it after the installation concludes. If you have installed for all users, uninstall Anaconda and re-install it for your user only and try again.\n",
        "\n",
        "4. Click Next.\n",
        "\n",
        "5. Read the licensing terms and click I Agree.\n",
        "\n",
        "6. Select an install for “Just Me” unless you’re installing for all users (which requires Windows Administrator privileges).\n",
        "\n",
        "7. Select a destination folder to install Anaconda and click Next.\n",
        "\n",
        "  NOTE: Install Anaconda to a directory path that does not contain spaces or unicode characters.\n",
        "\n",
        "  NOTE: Do not install as Administrator unless admin privileges are required.\n",
        "\n",
        "8. Choose whether to add Anaconda to your PATH environment variable. We recommend not adding Anaconda to the PATH environment variable, since this can interfere with other software. Instead, use Anaconda software by opening Anaconda Navigator or the Anaconda Command Prompt from the Start Menu.\n",
        "\n",
        "9. Choose whether to register Anaconda as your default Python 3.6. Unless you plan on installing and running multiple versions of Anaconda, or multiple versions of Python, you should accept the default and leave this box checked.\n",
        "\n",
        "10. Click Install. You can click Show Details if you want to see all the packages Anaconda is installing.\n",
        "\n",
        "11. Click Next.\n",
        "\n",
        "12. After a successful installation you will see the “Thanks for installing Anaconda” image:\n",
        " <img src=\"Images/anaconda-install-win.png\">\n",
        " \n",
        "13. You can leave the boxes checked “Learn more about Anaconda Cloud” and “Learn more about Anaconda Support” if you wish to read more about this cloud package management service and Anaconda support. Click Finish.\n",
        "\n",
        "14. After your install is complete, verify it by opening Anaconda Navigator, a program that is included with Anaconda. From your Windows Start menu, select the shortcut Anaconda Navigator. If Navigator opens, you have successfully installed Anaconda.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgdSRSffXapy",
        "colab_type": "text"
      },
      "source": [
        "## Installing on macOS\n",
        "1. Download the [graphical macOS installer](https://www.continuum.io/downloads#macos) for your version of Python.\n",
        "\n",
        "2. OPTIONAL: Verify data integrity with MD5 or SHA-256. For more information on hashes, see What about cryptographic hash verification?.\n",
        "\n",
        "3. Double-click the .pkg file.\n",
        "\n",
        "4. Answer the prompts on the Introduction, Read Me and License screens.\n",
        "\n",
        "5. On the Destination Select screen, select Install for me only.\n",
        "\n",
        " NOTE: If you get the error message “You cannot install Anaconda in this location,” reselect Install for me only.\n",
        " <img src=\"Images/osxbug2.png\">\n",
        "\n",
        "6. On the Installation Type screen, you may choose to install in another location. The standard install puts Anaconda in your home user directory:\n",
        " <img src=\"Images/customizebutton.png\">\n",
        "\n",
        "7. Click the Install button.\n",
        "\n",
        "8. A successful installation displays the following screen:\n",
        " <img src=\"Images/anaconda-install-osx.png\">\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4O3LZOjRXapz",
        "colab_type": "text"
      },
      "source": [
        "## Installing on Linux\n",
        "\n",
        "1. In your browser, download the Anaconda installer for Linux.\n",
        "\n",
        "2. Optional: Verify data integrity with MD5 or SHA-256. (For more information on hashes, see cryptographic hash validation.)\n",
        "\n",
        "    Run the following:\n",
        "\n",
        "    __md5sum /path/filename__\n",
        "    OR:\n",
        "\n",
        "    __sha256sum /path/filename__\n",
        "3. Verify results against the proper hash page to make sure the hashes match.\n",
        "\n",
        "4. Enter the following to install Anaconda for Python 3.6:\n",
        "\n",
        " __bash ~/Downloads/Anaconda3-4.4.0-Linux-x86_64.sh__\n",
        " OR\n",
        "\n",
        " Enter the following to install Anaconda for Python 2.7:\n",
        "\n",
        " __bash ~/Downloads/Anaconda2-4.4.0-Linux-x86_64.sh__\n",
        " NOTE: You should include the bash command regardless of whether you are using Bash shell.\n",
        "\n",
        " NOTE: Replace actual download path and filename as necessary.\n",
        "\n",
        " NOTE: Install Anaconda as a user unless root privileges are required.\n",
        "\n",
        "5. The installer prompts “In order to continue the installation process, please review the license agreement.” Click Enter to view license terms.\n",
        "\n",
        "6. Scroll to the bottom of the license terms and enter yes to agree to them.\n",
        "\n",
        "7. The installer prompts you to click Enter to accept the default install location, press CTRL-C to cancel the installation, or specify an alternate installation directory. If you accept the default install location, the installer displays __'PREFIX=/home/\"user\"/anaconda\"2 or 3\"' and continues the installation. It may take a few minutes to complete.__\n",
        "\n",
        "   The installer prompts “Do you wish the installer to prepend the Anaconda\"2 or 3\" install location to PATH in your /home/\"user\"/.bashrc ?” We recommend yes.\n",
        "\n",
        " NOTE: If you enter “no”, you will need to manually specify the path to Anaconda when using Anaconda. To manually add the prepended path, edit file .bashrc to add ~/anaconda\"2 or 3\"/bin to your path manually using:\n",
        "\n",
        "8. __export PATH=\"/home/\"user\"/anaconda\"2 or 3\"/bin:$PATH\"__\n",
        " Replace /home/\"user\"/anaconda\"2 or 3\" with the actual path.\n",
        "\n",
        "9. The installer finishes and displays “Thank you for installing Anaconda\"2 or 3\"!”\n",
        "\n",
        "10. Close and open your terminal window for the installation to take effect, or you can enter the command source ~/.bashrc.\n",
        "\n",
        "  Enter conda list. If the installation was successful, the terminal window should display a list of installed Anaconda packages.\n",
        "\n",
        "  NOTE: Power8 users: Navigate to your Anaconda directory and run this command:\n",
        "\n",
        " __conda install libgfortran__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0WwoEWNXap1",
        "colab_type": "text"
      },
      "source": [
        "## What are Jupyter notebook?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bKV4h67nXap2",
        "colab_type": "text"
      },
      "source": [
        "The notebook is a web application that allows you to combine explanatory text, math equations, code, and visualizations all in one easily sharable document.\n",
        "\n",
        "Notebooks have quickly become an essential tool when working with data. You'll find them being used for data cleaning and exploration, visualization, machine learning, and big data analysis. Typically you'd be doing this work in a terminal, either the normal Python shell or with IPython. Your visualizations would be in separate windows, any documentation would be in separate documents, along with various scripts for functions and classes. However, with notebooks, all of these are in one place and easily read together.\n",
        "\n",
        "Notebooks are also rendered automatically on GitHub. It’s a great feature that lets you easily share your work. There is also [http://nbviewer.jupyter.org/](http://nbviewer.jupyter.org/) that renders the notebooks from your GitHub repo or from notebooks stored elsewhere.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xeHKULeWXap3",
        "colab_type": "text"
      },
      "source": [
        "## How notebook works?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "awWa_nB5Xap4",
        "colab_type": "text"
      },
      "source": [
        "Jupyter notebooks grew out of the IPython project started by Fernando Perez. IPython is an interactive shell, similar to the normal Python shell but with great features like syntax highlighting and code completion. Originally, notebooks worked by sending messages from the web app (the notebook you see in the browser) to an IPython kernel (an IPython application running in the background). The kernel executed the code, then sent it back to the notebook. The current architecture is similar, drawn out below.\n",
        "<img src=\"Images/notebook-components.png\">\n",
        "\n",
        "\n",
        "The central point is the notebook server. You connect to the server through your browser and the notebook is rendered as a web app. Code you write in the web app is sent through the server to the kernel. The kernel runs the code and sends it back to the server, then any output is rendered back in the browser. When you save the notebook, it is written to the server as a JSON file with a .ipynb file extension.\n",
        "\n",
        "The great part of this architecture is that the kernel doesn't need to run Python. Since the notebook and the kernel are separate, code in any language can be sent between them. For example, two of the earlier non-Python kernels were for the R and Julia languages. With an R kernel, code written in R will be sent to the R kernel where it is executed, exactly the same as Python code running on a Python kernel. IPython notebooks were renamed because notebooks became language agnostic. The new name Jupyter comes from the combination of Julia, Python, and R. If you're interested, here's a list of available kernels.\n",
        "\n",
        "Another benefit is that the server can be run anywhere and accessed via the internet. Typically you'll be running the server on your own machine where all your data and notebook files are stored. But, you could also set up a server on a remote machine or cloud instance like Amazon's EC2. Then, you can access the notebooks in your browser from anywhere in the world.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qe5u2ODqXap5",
        "colab_type": "text"
      },
      "source": [
        "## Installing Jupyter Notebook"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hX0BgZ_tXap6",
        "colab_type": "text"
      },
      "source": [
        "By far the easiest way to install Jupyter is with Anaconda. Jupyter notebooks automatically come with the distribution. You'll be able to use notebooks from the default environment.\n",
        "\n",
        "To install Jupyter notebooks in a conda environment, use __conda install jupyter notebook__.\n",
        "\n",
        "Jupyter notebooks are also available through pip with __pip install jupyter notebook__."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hqPgczXzXap7",
        "colab_type": "text"
      },
      "source": [
        "## Launching the notebook server\n",
        "\n",
        "To start a notebook server, enter jupyter notebook in your terminal or console. This will start the server in the directory you ran the command in. That means any notebook files will be saved in that directory. Typically you'd want to start the server in the directory where your notebooks live. However, you can navigate through your file system to where the notebooks are.\n",
        "\n",
        "When you run the command (try it yourself!), the server home should open in your browser. By default, the notebook server runs at http://localhost:8888. If you aren't familiar with this, localhost means your computer and 8888 is the port the server is communicating on. As long as the server is still running, you can always come back to it by going to http://localhost:8888 in your browser.\n",
        "\n",
        "If you start another server, it'll try to use port 8888, but since it is occupied, the new server will run on port 8889. Then, you'd connect to it at http://localhost:8889. Every additional notebook server will increment the port number like this.\n",
        "\n",
        "If you tried starting your own server, it should look something like this:\n",
        "<img src=\"Images/notebook-server.png\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHuLD-90Xap8",
        "colab_type": "text"
      },
      "source": [
        "# -------------------------------------------------------------------------------------------------------------"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZY5ZVkRXap-",
        "colab_type": "text"
      },
      "source": [
        "## Basics of Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J2hGQmnmXap_",
        "colab_type": "text"
      },
      "source": [
        "Python is a high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable. As an example, here is an implementation of the classic quicksort algorithm in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ziUjJajiXaqA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yNZHt4JBXaqD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pp8LOgejXaqH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w-3OVvzZXaqK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPsj5y8jXaqR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jOQ2-xcEXaqW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dMGFE3prXaqZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "exem8BoPXaqc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qodOKUySXaqg",
        "colab_type": "text"
      },
      "source": [
        "### Fundamental types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CPwC4G2cXaqh",
        "colab_type": "text"
      },
      "source": [
        "### Integers\n",
        "\n",
        "Integer literals are created by any number without a decimal or complex component."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFU24igIXaqi",
        "colab_type": "text"
      },
      "source": [
        "# fhfhfhhdfhdfhgdfgdfghlfklhjkflhjdfhjdfkhdfjhg"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "zoN-sQyjXaqj",
        "colab_type": "code",
        "colab": {},
        "outputId": "a8da691c-b69a-4ab8-b10c-fbf38dce326a"
      },
      "source": [
        "# integers\n",
        "a = 7\n",
        "print(\"fggdgsgd\" + str(a))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "fggdgsgd7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3H3LXdZ9Xaqn",
        "colab_type": "text"
      },
      "source": [
        "### Floats\n",
        "\n",
        "Float literals can be created by adding a decimal component to a number."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NRT2t4TeXaqo",
        "colab_type": "code",
        "colab": {},
        "outputId": "0cfbb9d6-5dc3-4142-d4f1-32d348d5f30a"
      },
      "source": [
        "# float\n",
        "x = 1\n",
        "type(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e-68etOHXaqr",
        "colab_type": "text"
      },
      "source": [
        "### Boolean\n",
        "\n",
        "Boolean can be defined by typing True/False without quotes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gy7RJbD_Xaqs",
        "colab_type": "code",
        "colab": {},
        "outputId": "25e208ba-8910-4ae6-8078-8c4fd397fc2e"
      },
      "source": [
        "# boolean\n",
        "b1 = True\n",
        "b2 = False\n",
        "\n",
        "type(b1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z_tnaM6CXaqy",
        "colab_type": "text"
      },
      "source": [
        "### Strings\n",
        "\n",
        "String literals can be defined with any of single quotes ('), double quotes (\") or triple quotes (''' or \"\"\"). All give the same result with two important differences.\n",
        "\n",
        "If you quote with single quotes, you do not have to escape double quotes and vice-versa.\n",
        "If you quote with triple quotes, your string can span multiple lines."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2N-ALfKIXaqz",
        "colab_type": "code",
        "colab": {},
        "outputId": "2420948a-727a-4f54-a767-d790ccf092eb"
      },
      "source": [
        "# string\n",
        "name1 = 'your name vvgafdasfasfasfa'\n",
        "type(name1)\n",
        "name1."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eU7fKZGuXaq4",
        "colab_type": "text"
      },
      "source": [
        "### Complex\n",
        "\n",
        "Complex literals can be created by using the notation x + yj where x is the real component and y is the imaginary component."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "er6BFmWpXaq5",
        "colab_type": "code",
        "colab": {},
        "outputId": "f62658fe-c08b-4ed3-8f80-bb8b0130372b"
      },
      "source": [
        "#complex numbers: note the use of `j` to specify the imaginary part\n",
        "\n",
        "\n",
        "j = 1.0 - 2.0j\n",
        "\n",
        "j\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1-2j)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "5gDagOIHXarA",
        "colab_type": "code",
        "colab": {},
        "outputId": "e0eb1c6a-6f54-440f-a8dd-aacd3f330721"
      },
      "source": [
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1-2j)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "jaY8g_OyXarG",
        "colab_type": "code",
        "colab": {},
        "outputId": "5ba07b3c-19c8-44d8-e9ce-9ca523a6cd1b"
      },
      "source": [
        "print(x.real, x.imag)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0 -2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vk_pZP5QXarJ",
        "colab_type": "text"
      },
      "source": [
        "### Variables\n",
        "\n",
        "#### Definining\n",
        "\n",
        "A variable in Python is defined through assignment. There is no concept of declaring a variable outside of that assignment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nZBr9SoQXarK",
        "colab_type": "code",
        "colab": {},
        "outputId": "b6db81a0-ca9e-4b2e-bb12-af52fcbd12d3"
      },
      "source": [
        "tenth = 10\n",
        "tenth"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QzlkjOYXXarO",
        "colab_type": "text"
      },
      "source": [
        "#### Dynamic Typing\n",
        "\n",
        "In Python, while the value that a variable points to has a type, the variable itself has no strict type in its definition. You can re-use the same variable to point to an object of a different type. It may be helpful to think of variables as \"labels\" associated with objects."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "csTGMO98XarO",
        "colab_type": "code",
        "colab": {},
        "outputId": "57a66ad1-3afa-4d84-f462-ac4aec0de421"
      },
      "source": [
        "ten = 10\n",
        "ten"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DSqsihnVXarS",
        "colab_type": "code",
        "colab": {},
        "outputId": "e80e6054-6c6c-427a-c889-bdc4ee3d2fe5"
      },
      "source": [
        "ten = 'ten'\n",
        "ten"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ten'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RhgiT308XarV",
        "colab_type": "text"
      },
      "source": [
        "#### Strong Typing\n",
        "\n",
        "While Python allows you to be very flexible with your types, you must still be aware of what those types are. Certain operations will require certain types as arguments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WAzaDHjbXarX",
        "colab_type": "code",
        "colab": {},
        "outputId": "88bcb7fd-14a9-4688-955f-055c6ce9199e"
      },
      "source": [
        "'Day ' +str(1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Day 1'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y4DE3sriXara",
        "colab_type": "text"
      },
      "source": [
        "This behavior is different from some other loosely-typed languages. If you were to do the same thing in JavaScript, you would get a different result.\n",
        "\n",
        "In Python, however, it is possible to change the type of an object through builtin functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8WZkTPD3Xarb",
        "colab_type": "text"
      },
      "source": [
        "# 'Day ' + str(1)\n",
        "\n",
        "\n",
        "and \n",
        "0 0 0\n",
        "0 1 0\n",
        "1 0 0\n",
        "1 1 1 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgb8GkCaXarc",
        "colab_type": "text"
      },
      "source": [
        "## Simple Expressions\n",
        "\n",
        "### Boolean Evaluation\n",
        "\n",
        "Boolean expressions are created with the keywords and, or, not and is. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mXcWdYgzXard",
        "colab_type": "code",
        "colab": {},
        "outputId": "1be7b79d-21cf-4f13-e076-12279e2150d4"
      },
      "source": [
        "True and False"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ptAHDEElXarg",
        "colab_type": "code",
        "colab": {},
        "outputId": "4f0f1d0a-a465-47bc-fb5f-83087377e1e9"
      },
      "source": [
        "True or False"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2uywpetMXarl",
        "colab_type": "code",
        "colab": {},
        "outputId": "498b050d-2d61-44ca-94f9-bd0a528fbc24"
      },
      "source": [
        "not True"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "74fvjLapXaro",
        "colab_type": "code",
        "colab": {},
        "outputId": "90e24d3c-86b3-4b04-b1b2-b78311d375e4"
      },
      "source": [
        "not False"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeMC0xJCXarr",
        "colab_type": "code",
        "colab": {},
        "outputId": "38e9a001-d064-4a3c-8aeb-50ab62227824"
      },
      "source": [
        "True is True"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5NTGXq29Xart",
        "colab_type": "code",
        "colab": {},
        "outputId": "3f5a64eb-3fff-4c85-83e7-8391cbf131a9"
      },
      "source": [
        "True is False"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mS2ls16SXarw",
        "colab_type": "code",
        "colab": {},
        "outputId": "01026f87-c425-4806-ffc7-1e1ebb67a484"
      },
      "source": [
        "'a' is 'a'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loI66HDCXar0",
        "colab_type": "text"
      },
      "source": [
        "## Branching (if / elif / else)\n",
        "\n",
        "Python provides the if statement to allow branching based on conditions. Multiple elif checks can also be performed followed by an optional else clause. The if statement can be used with any evaluation of truthiness."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36pvZ0frXar1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pD8s3GemXar4",
        "colab_type": "code",
        "colab": {},
        "outputId": "a565a6aa-a91c-4bf4-bd6d-cb8816a59ffd"
      },
      "source": [
        "i = 1\n",
        "if (i < 3):\n",
        "    print('less than 3')\n",
        "    if i<2:\n",
        "        print(\"Fsdfsf\")\n",
        "elif i < 5:\n",
        "    print('less than 5')\n",
        "else:\n",
        "    print('5 or more')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "less than 3\n",
            "Fsdfsf\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hOVOlweGXar6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ccXKKproXar9",
        "colab_type": "text"
      },
      "source": [
        "## Block Structure and Whitespace\n",
        "\n",
        "The code that is executed when a specific condition is met is defined in a \"block.\" In Python, the block structure is signalled by changes in indentation. Each line of code in a certain block level must be indented equally and indented more than the surrounding scope. The standard (defined in PEP-8) is to use 4 spaces for each level of block indentation. Statements preceding blocks generally end with a colon (:).\n",
        "\n",
        "Because there are no semi-colons or other end-of-line indicators in Python, breaking lines of code requires either a continuation character (\\ as the last char) or for the break to occur inside an unfinished structure (such as open parentheses).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2patdFr3Xar9",
        "colab_type": "text"
      },
      "source": [
        "## Advanced Types: Containers\n",
        "\n",
        "One of the great advantages of Python as a programming language is the ease with which it allows you to manipulate containers. Containers (or collections) are an integral part of the language and, as you’ll see, built in to the core of the language’s syntax. As a result, thinking in a Pythonic manner means thinking about containers.\n",
        "\n",
        "### Lists\n",
        "\n",
        "The first container type that we will look at is the list. A list represents an ordered, mutable collection of objects. You can mix and match any type of object in a list, add to it and remove from it at will.\n",
        "\n",
        "Creating Empty Lists. To create an empty list, you can use empty square brackets or use the list() function with no arguments.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kRXUKfvrXar-",
        "colab_type": "code",
        "colab": {},
        "outputId": "c9254392-f6a0-4452-ca76-27d5d177ebbe"
      },
      "source": [
        "l = []\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eDKJ51dFXasC",
        "colab_type": "code",
        "colab": {},
        "outputId": "ced809bc-8236-4fe7-d96f-630cc155e2c2"
      },
      "source": [
        "l = list()\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9bfLWG6QXasI",
        "colab_type": "text"
      },
      "source": [
        "Initializing Lists. You can initialize a list with content of any sort using the same square bracket notation. The list() function also takes an iterable as a single argument and returns a shallow copy of that iterable as a new list. A list is one such iterable as we’ll see soon, and we’ll see others later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MNp9YprFXasJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l1 = [\"dsad\", 'b', 'c']\n",
        "l2 = ['a',6,4.0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u396ForaXasO",
        "colab_type": "code",
        "colab": {},
        "outputId": "56d70679-466b-469d-b5d4-d9a4cb5edab8"
      },
      "source": [
        "\n",
        "l1  + l2 "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['dsad', 'b', 'c', 'a', 6, 4.0]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JTgquk-rXasR",
        "colab_type": "code",
        "colab": {},
        "outputId": "7dc87252-83ec-4ddc-db11-75927ef32a0c"
      },
      "source": [
        "l"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['j', 'k', 'd', 'f', 'g', 'k', 'd', 'g', 'j']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7eM_57uXasW",
        "colab_type": "text"
      },
      "source": [
        "A Python string is also a sequence of characters and can be treated as an iterable over those characters. Combined with the list() function, a new list of the characters can easily be generated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iThaHRL9XasX",
        "colab_type": "code",
        "colab": {},
        "outputId": "fe2eabf4-135c-4ca1-c966-f71df835865c"
      },
      "source": [
        "l=list(\"jkdfgkdgj\")\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['j', 'k', 'd', 'f', 'g', 'k', 'd', 'g', 'j']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XzVaiWUqXasZ",
        "colab_type": "text"
      },
      "source": [
        "Adding. You can append to a list very easily (add to the end) or insert at an arbitrary index."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ijh2jti8XasZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "e48e47e6-ad78-4ac6-b516-f9bfed848dee"
      },
      "source": [
        "l"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['j', 'k', 'd', 'f', 'g', 'k', 'd', 'g', 'j']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oZQfYPwUXasc",
        "colab_type": "text"
      },
      "source": [
        "Iterating. Iterating over a list is very simple. All iterables in Python allow access to elements using the for ... in statement. In this structure, each element in the iterable is sequentially assigned to the \"loop variable\" for a single pass of the loop, during which the enclosed block is executed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6JvI996CXasg",
        "colab_type": "code",
        "colab": {},
        "outputId": "8c153efa-fdcb-49ee-bb4a-1682fdd5e107"
      },
      "source": [
        "for fg in l:\n",
        "    print((fg))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "j\n",
            "k\n",
            "d\n",
            "f\n",
            "g\n",
            "k\n",
            "d\n",
            "g\n",
            "j\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ybo4YZqGXasi",
        "colab_type": "text"
      },
      "source": [
        "## Loops\n",
        "\n",
        "In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times.\n",
        "\n",
        "Programming languages provide various control structures that allow for more complicated execution paths.\n",
        "\n",
        "### For loop\n",
        "\n",
        "The for loop in Python is used to iterate over a sequence (list, tuple, string) or other iterable objects. Iterating over a sequence is called traversal.\n",
        "\n",
        "Loop continues until we reach the last item in the sequence. The body of for loop is separated from the rest of the code using indentation.\n",
        "\n",
        "\n",
        "<img src=\"Images/forLoop.jpg\">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4jmdLx5vXasj",
        "colab_type": "code",
        "colab": {},
        "outputId": "7ca0f1cf-2098-4e08-98b2-e258b8630883"
      },
      "source": [
        "# Program to find the sum of all numbers stored in a list\n",
        "\n",
        "# List of numbers\n",
        "numbers = [\"Fsdfsf\",\"fsdfs\",\"sdffsfs\"]\n",
        "\n",
        "# variable to store the sum\n",
        "summ=''\n",
        "\n",
        "# iterate over the list\n",
        "for x in numbers:\n",
        "    summ = summ+x\n",
        "\n",
        "# Output: The sum is 48\n",
        "print(summ)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cgcgf    Fsdfsffsdfssdffsfs\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YTWWP0DaXasm",
        "colab_type": "text"
      },
      "source": [
        "### for loop with else\n",
        "A for loop can have an optional else block as well. The else part is executed if the items in the sequence used in for loop exhausts.\n",
        "\n",
        "break statement can be used to stop a for loop. In such case, the else part is ignored.\n",
        "\n",
        "Hence, a for loop's else part runs if no break occurs.\n",
        "\n",
        "Here is an example to illustrate this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YWTF2WE6Xasm",
        "colab_type": "code",
        "colab": {},
        "outputId": "1df62f11-4673-485e-b58a-9b3c87fc7d21"
      },
      "source": [
        "digits = [0, 1, 5]\n",
        "\n",
        "for sfdsf in [0,1,2,3]:\n",
        "    if sfdsf == 3:\n",
        "        break\n",
        "else:\n",
        "    print(\"No items left.\")\n",
        "print(\"Fsdfsfsf\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fsdfsfsf\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fBa3pwyMXasp",
        "colab_type": "text"
      },
      "source": [
        "## While loop\n",
        "\n",
        "The while loop in Python is used to iterate over a block of code as long as the test expression (condition) is true.\n",
        "\n",
        "We generally use this loop when we don't know beforehand, the number of times to iterate.\n",
        "\n",
        "In while loop, test expression is checked first. The body of the loop is entered only if the test_expression evaluates to True. After one iteration, the test expression is checked again. This process continues until the test_expression evaluates to False.\n",
        "\n",
        "In Python, the body of the while loop is determined through indentation.\n",
        "\n",
        "Body starts with indentation and the first unindented line marks the end.\n",
        "\n",
        "Python interprets any non-zero value as True. None and 0 are interpreted as False.\n",
        "\n",
        "<img src=\"Images/whileLoopFlowchart.jpg\">\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UgkzpQUVXasp",
        "colab_type": "code",
        "colab": {},
        "outputId": "64010cb5-04af-4605-e1d6-ec439923d617"
      },
      "source": [
        "# Program to add natural\n",
        "# numbers upto \n",
        "# sum = 1+2+3+...+n\n",
        "\n",
        "# To take input from the user,\n",
        "# n = int(input(\"Enter n: \"))\n",
        "\n",
        "n = 10\n",
        "\n",
        "# initialize sum and counter\n",
        "sum = 0\n",
        "i = 1\n",
        "\n",
        "while i <= n:\n",
        "    sum = sum + i\n",
        "    i = i+1    # update counter\n",
        "\n",
        "# print the sum\n",
        "print(\"The sum is\", sum)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The sum is 55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sF-qgm68Xasr",
        "colab_type": "text"
      },
      "source": [
        "## The range() function\n",
        "We can generate a sequence of numbers using range() function. range(10) will generate numbers from 0 to 9 (10 numbers).\n",
        "\n",
        "We can also define the start, stop and step size as range(start,stop,step size). step size defaults to 1 if not provided.\n",
        "\n",
        "This function does not store all the values in memory, it would be inefficient. So it remembers the start, stop, step size and generates the next number on the go.\n",
        "\n",
        "To force this function to output all the items, we can use the function list().\n",
        "\n",
        "The following example will clarify this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1icUyOLXass",
        "colab_type": "code",
        "colab": {},
        "outputId": "0d50b58a-7c53-4b2e-d6e8-a91d1461d7c2"
      },
      "source": [
        "range(6)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 6)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkzSiHGEXasw",
        "colab_type": "code",
        "colab": {},
        "outputId": "12175b32-6291-4169-85ca-4b276ef7faf9"
      },
      "source": [
        "list(range(10))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xisEPG0kXas0",
        "colab_type": "code",
        "colab": {},
        "outputId": "7074e0a2-cfda-4bef-c6a6-c3eee5449cde"
      },
      "source": [
        "print(list(range(8, 2,-2)))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8, 6, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y_zMdd_qXas3",
        "colab_type": "code",
        "colab": {},
        "outputId": "ab846f05-eefe-46b2-f678-54a8131cccb3"
      },
      "source": [
        "print(list(range(2, 20, 5)))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 7, 12, 17]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lauzXSJ2Xas6",
        "colab_type": "code",
        "colab": {},
        "outputId": "75a2a2cf-8790-47d3-b553-64b20c105d2d"
      },
      "source": [
        "list(range(len(genre)-1,0,-2))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AixVhOOPXas8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5M4Q9AbpXas9",
        "colab_type": "text"
      },
      "source": [
        "We can use the range() function in for loops to iterate through a sequence of numbers. It can be combined with the len() function to iterate though a sequence using indexing. Here is an example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XDrIYP7yXas-",
        "colab_type": "code",
        "colab": {},
        "outputId": "31a874c5-2120-4428-8f48-eddd8d02c914"
      },
      "source": [
        "# Program to iterate through a list using indexing\n",
        "\n",
        "genre = ['pop', 'rock', 'jazz','sapna']\n",
        "\n",
        "# iterate over the list using index\n",
        "for i in range(len(genre)-1,0,-2):\n",
        "    print(\"I like\", genre[i])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I like sapna\n",
            "I like rock\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D2Tc7VmRXatA",
        "colab_type": "text"
      },
      "source": [
        "## break and continue statement\n",
        "\n",
        "In Python, break and continue statements can alter the flow of a normal loop.\n",
        "\n",
        "Loops iterate over a block of code until test expression is false, but sometimes we wish to terminate the current iteration or even the whole loop without cheking test expression.\n",
        "\n",
        "The break and continue statements are used in these cases.\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",
        "If break statement is inside a nested loop (loop inside another loop), break will terminate the innermost loop.\n",
        "\n",
        "\n",
        "\n",
        "<img src=\"Images/flowchart-break-statement.jpg\">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9VBe-DzzXatE",
        "colab_type": "code",
        "colab": {},
        "outputId": "a87244ba-8223-449a-9c32-0edadcebe893"
      },
      "source": [
        "# Use of break statement inside loop\n",
        "\n",
        "for val in \"string\":\n",
        "    if val == \"i\":\n",
        "        break\n",
        "    print(val)\n",
        "\n",
        "print(\"The end\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "s\n",
            "t\n",
            "r\n",
            "The end\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HODmWZpjXatM",
        "colab_type": "text"
      },
      "source": [
        "In this program, we iterate through the \"string\" sequence. We check if the letter is \"i\", upon which we break from the loop. Hence, we see in our output that all the letters up till \"i\" gets printed. After that, the loop terminates."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IGMgt_18XatN",
        "colab_type": "text"
      },
      "source": [
        "### continue\n",
        "The continue statement is used to skip the rest of the code inside a loop for the current iteration only. Loop does not terminate but continues on with the next iteration.\n",
        "\n",
        "<img src=\"Images/continue-statement-flowchart.jpg\">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XjYtFI0MXatO",
        "colab_type": "code",
        "colab": {},
        "outputId": "a586db58-ed2e-44e4-a483-544368672ec4"
      },
      "source": [
        "# Program to show the use of continue statement inside loops\n",
        "\n",
        "for val in \"string\":\n",
        "    if val == \"i\":\n",
        "        continue\n",
        "    print(val)\n",
        "\n",
        "print(\"The end\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "s\n",
            "t\n",
            "r\n",
            "n\n",
            "g\n",
            "The end\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N4OZzCouXatR",
        "colab_type": "text"
      },
      "source": [
        "This program is same as the above example except the break statement has been replaced with continue.\n",
        "\n",
        "We continue with the loop, if the string is \"i\", not executing the rest of the block. Hence, we see in our output that all the letters except \"i\" gets printed."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "PqxbM3KiXatU",
        "colab_type": "text"
      },
      "source": [
        "my own work.........."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EjVTCEcyXatX",
        "colab_type": "code",
        "colab": {},
        "outputId": "70b043f1-49ea-486c-f8ef-5664e91f3754"
      },
      "source": [
        "# Program to take the input string from the user.\n",
        "\n",
        "name = input(\"What is your name? \")\n",
        "type(name)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "What is your name? satyam\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bfi8JyJ6Xate",
        "colab_type": "code",
        "colab": {},
        "outputId": "44678136-6f14-43e2-f565-3910bae033df"
      },
      "source": [
        "# Program to read integers from user\n",
        "\n",
        "age = input(\"What is your age? \")\n",
        "print (\"Your age is: \", age)\n",
        "type(age)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "What is your age? 25\n",
            "Your age is:  25\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVNl7OddXatg",
        "colab_type": "code",
        "colab": {},
        "outputId": "0ce372a2-cd9a-41c3-bbf9-5350f705b4bb"
      },
      "source": [
        "# Let's have one more example\n",
        "\n",
        "name = input(\"What is your name? \")\n",
        "print (\" It was nice talking you \" + name + \"!\")\n",
        "age = input(\"Enter your age? \")\n",
        "print(\"Hey, you are already \" + age + \" years old, \" + name + \"!\")\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "What is your name? Onkar\n",
            " It was nice talking you Onkar!\n",
            "Enter your age? 25\n",
            "Hey, you are already 25 years old, Onkar!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "HJe54JcyXatm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}