Copy_of_python_tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of python_tutorial.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [
        "z3t9FYuNTbaP",
        "_GvUvrQbOOvJ",
        "JySEebjxOOvc",
        "wQKoMG92OOv6",
        "zxIUS5f6OOxD",
        "M7viXmChOOxk",
        "1_uyDXdXOOyE",
        "zNc5Ra4KOOyL",
        "Dc3WeauW0bGE",
        "nosy-jlAOOzi",
        "HtTgCpqxOOzn",
        "84Rj4ukDOOzr",
        "IGk6izvIOOz1",
        "un7gh-yaRAMI",
        "QBmRIkrcMMy1"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python [default]",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/github/star-ice/tensorflow/blob/master/Copy_of_python_tutorial.ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "hIqzqDr1OOuB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Python Crash Course\n",
        "\n",
        "*(Compiled from various sources on the internet by HK Tan and myself)*"
      ]
    },
    {
      "metadata": {
        "id": "ilALUb-FPJZw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Quick note about Jupyter\n",
        "\n",
        "This document is a Jupyter notebook. A Jupyter notebook consists of **text** cells and/or **code** cells. \n",
        "\n",
        "**Text cells** consists of instruction text while **code cells** contains Python codes.\n",
        "\n",
        "You can run a code cell by moving the cursor to the cell's left-hand side. A run button  ![代替テキスト](https://raw.githubusercontent.com/kalngyk/repoman/master/run.png) will appear. Clicking on the \"run\" button executes the cell. After that, the run button turns into a stop button ![代替テキスト](https://raw.githubusercontent.com/kalngyk/repoman/master/stop.png) -- clicking on the stop button will interrupt the cell's execution. When the execution ends, the stop button turns back into a run button. If the execution runs into problem, the stop cursor will turn into a red-colored run button ![代替テキスト](https://raw.githubusercontent.com/kalngyk/repoman/master/error.png) to indicate that the execution failed.\n",
        "\n",
        "*Tips: While your cursor is within a code cell, you can run the cell by pressing **`<Shift>+<Enter>`** instead of clicking the run button.*\n",
        "\n",
        "The output messages of a code cell is shown immediately below the cell. You can clear the output messages of a cell by right-clicking over the \"run\" button and selecting **\"Clear output\"**. The menu which shows up when you right-click over the \"run\" button also allows you to delete the associated cell.\n",
        "\n",
        "To create a new cell or reposition a cell, use the menu at the top of the page: ![代替テキスト](https://raw.githubusercontent.com/kalngyk/repoman/master/menubar.png).\n",
        "\n",
        "*Tips: Pressing* **`<Control>+<s>`** *saves changes you have made to the notebook.*\n",
        "\n",
        "## Quick note about Google Colab\n",
        "\n",
        "This Jupyter notebook runs on Google Colab, a free cloud platform for running Python codes with **GPU support**. To enable/disable GPU for a notebook, go to the top menu and choose \"**Edit**> **Notebook Settings**> **Hardware Accelarator**\".\n",
        "\n",
        "When a colab session is first started, a VM (virtual machine) is assigned to the session to store your files as well as execute your codes. However, each session lasts only for 12 hours. When the session ends, your variables and files created during the session is deleted. While you can continue to work by restarting a new session, you will need to restore your variables and files. To make saving and restoring files easy, we have made it possible for you to store your files on Google Cloud and copy them back with just a simple command. However, you will need to **let us know your Google account name** for us to grant you permission to use our Google Cloud storage."
      ]
    },
    {
      "metadata": {
        "id": "lILxwOnqAdmH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "#Section 1: Operators and variables"
      ]
    },
    {
      "metadata": {
        "id": "z3t9FYuNTbaP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Arithmetic operators\n",
        "The Python interpreter can be used to evaluate expressions, for example simple arithmetic expressions."
      ]
    },
    {
      "metadata": {
        "id": "fb5lWi7NOOuC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# This is a comment\n",
        "1 + 1   # addition operation"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JMPEBfQWOOuI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f7a338e3-b81f-40cf-df93-1fe3157262b0"
      },
      "cell_type": "code",
      "source": [
        "2 * 3   # multiplication operaiton"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "metadata": {
        "id": "2sjN9NIOOOuM",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "11 / 3  # Normal division"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "N-qOxu-COOuR",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "11 // 3 # integer division"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "6-tSBXKvOOuV",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "11 % 3  # modulus operation"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "le-LompsOOuY",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "2 ** 3  # exponent operation"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "VpP6Zc7SOOud",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Boolean operators also exist in Python to manipulate the primitive True and False values."
      ]
    },
    {
      "metadata": {
        "id": "D1wJoTcKOOud",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "1 == 0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "1WkICa0XOOuh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "not (1 == 0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Beq0EP_GOOuk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "(2 == 2) and (2 == 3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "XOK9VHFmOOvG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "(2 == 2) or (2 == 3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_GvUvrQbOOvJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Variables\n",
        "\n",
        "We can also store expressions into variables. Here are some important rules about using variables in Python:\n",
        "\n",
        "You do not have to perform variable declaration, but a variable must be created before it can be used. (In Jupyter notebook, the variables created by running a code cell is immediately available in other code cells.)\n",
        "\n",
        "The type of a variable is automatically determined based on the value assigned.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "AT9nl63mOOvJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6f1492dc-cff3-4e58-c571-772012481caf"
      },
      "cell_type": "code",
      "source": [
        "s = 'hello world'   # defining a variable\n",
        "print(s)\n",
        "print(type(s))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "H1SidTyDOOvM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "In the above code, we use `type` to display the type of `s`. Since 'hello world' is a string, the variable `s` is of type string."
      ]
    },
    {
      "metadata": {
        "id": "BUHJHtxrOOvM",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "fval = 7.3   # this will create a floating point variable\n",
        "print(fval)\n",
        "print(type(fval))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ftnH5MOEOOvR",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "ival = 12    # this will create an integer variable\n",
        "print(ival)\n",
        "print(type(ival))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dYAVc6yWOOvT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        },
        "outputId": "3406027a-d153-483f-bdb3-0a4ab4b31148"
      },
      "cell_type": "code",
      "source": [
        "fval += 2.5  # operate on fval\n",
        "print(fval)  # you can print the content of a variable  using print command"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-1436d41950a7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfval\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m2.5\u001b[0m  \u001b[0;31m# operate on fval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfval\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# you can print the content of a variable  using print command\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'fval' is not defined"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "K5CE2L07OOvX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "800ae975-9e2f-4a20-ce43-a6f6bb79363b"
      },
      "cell_type": "code",
      "source": [
        "ival += 3    \n",
        "ival         # you can display the value of a variable by typing the variable name"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "metadata": {
        "id": "BAVGz6iAOOvZ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Remember that you cannot use a variable that you have not created. The following command will generate an error  because `var` has not been created."
      ]
    },
    {
      "metadata": {
        "id": "qhEyCqwmOOva",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        },
        "outputId": "226f7f4b-07dd-4415-8d1a-cf996b2d40db"
      },
      "cell_type": "code",
      "source": [
        "print(var)   # we have not defined a variable called var! This will generate an error!"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-0b65bda2f1d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# we have not defined a variable called var! This will generate an error!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'var' is not defined"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "JySEebjxOOvc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Importing libraries (modules)\n",
        "One reason for the popularity of Python is the large number of libraries (called modules) available for the language.\n",
        "\n",
        "To use a module, use the keyword `import`.\n",
        "\n",
        "The following codes import the math module, which enables you to use mathematical functions such as π (pi) and sine, cosine and tangent."
      ]
    },
    {
      "metadata": {
        "id": "8YxMrdK2OOvd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import math"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_IIdbtCwOOvg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print ('The sin of 90 degrees is', math.sin(math.pi/2))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zPUUg-ShOOvz",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print ('log of 100 is ', math.log(100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "1KvGvomL28V_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "If we are only interested in a particular function (or class) from a module, for example, if we only need `sqrt` from the `math` module, we may write the following:"
      ]
    },
    {
      "metadata": {
        "id": "aCTe8BvI3QHW",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from math import sqrt\n",
        "sqrt(2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "wQKoMG92OOv6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## The `string` class\n",
        "\n",
        "Like C++ and Java, Python has a built in string type. A `string` object can be defined with either a single quote (`'`)  or double quote (`\"`). "
      ]
    },
    {
      "metadata": {
        "id": "kC9kZJL5OOwB",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "s = 'hot'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "67vuxI1zOOwG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "s = s + 'dog' # or s += 'dog'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ZQX80sCuOOwL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "s             # display the value of the string object"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "jw6KV2i_OOwS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(s)      # printing the string object"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fQjb6yGrOOwY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Python is object-oriented. To show this let us consider the `string` class in the following codes.\n",
        "\n",
        "*(To see the list of functions provided by a class, type the object variable name and then press TAB. For example, typing  `s.<TAB>` will pop up a menu which shows the list of functions for the class.)*\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "3hiPCMNyOOwZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "s = 'HELP'\n",
        "s.lower()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "MjumCwGDOOwg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "'help'.upper()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Y5-jrggLOOwq",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To get the length of a string, you can use the `len` command."
      ]
    },
    {
      "metadata": {
        "id": "cmTCIAGOOOwr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "21e7c334-bad0-4162-b706-e5a07ef0aa53"
      },
      "cell_type": "code",
      "source": [
        "len('Help')"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "metadata": {
        "id": "aP97CwBNOOw3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can also use the command `help` to get help on commands."
      ]
    },
    {
      "metadata": {
        "id": "NX-YLNvuOOw4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "help(s.find)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zxIUS5f6OOxD",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Printing to screen\n",
        "\n",
        "The standard way for showing output messages is through the function `print`."
      ]
    },
    {
      "metadata": {
        "id": "7ia2DVnZOOxD",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "a = 3\n",
        "print('There are', a, 'people in the meeting')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "nWFpNKt_OOxG",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can format output using the `str.format()` method where we use the curly braces `{}` as placeholders.  \n",
        "\n",
        "In the following example, the first bracket `{}` would be replaced by `x` and the second by `y`. "
      ]
    },
    {
      "metadata": {
        "id": "5l8CS1xVOOxG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0302dd89-1dcf-45b8-fd25-803289c8876d"
      },
      "cell_type": "code",
      "source": [
        "x = 5; y = 10\n",
        "print('The value of x is {} and y is {}'.format(x,y))"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The value of x is 5 and y is 10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "bUBr9E7AOOxJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We can also specify *the order* in which it is printed by using numbers (tuple index).\n",
        "\n",
        "In the following example, the placeholder `{0}` would be replaced by the first parameter `bread` regardless of its position in the `print` statement. Similarly for the placeholder `{1}`. "
      ]
    },
    {
      "metadata": {
        "id": "JguPD4mUOOxJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "edc4b347-930e-4b06-ed2c-0198c77ed5d2"
      },
      "cell_type": "code",
      "source": [
        "print('I love {0} and {1}'.format('bread', 'butter'))\n",
        "print('I love {1} and {0}'.format('bread', 'butter'))  # changing the order"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I love bread and butter\n",
            "I love butter and bread\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "69oiUITyOOxM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Formatting of integer values can be done as in the following example, where\n",
        "* `d` specifies that the placedholder is to be replaced by an *integer*. \n",
        "* `6` specifies that a total of 6 characters would be allocated to print out the integer."
      ]
    },
    {
      "metadata": {
        "id": "6li4FUQJOOxO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print('Integer value is {:d}.'.format(23))\n",
        "print('Integer value is {:6d}.'.format(23))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xX9FDgwxOOxR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Formatting of floating point values can be done as in the following example, where\n",
        "* `f`  specifies that the placedholder is to be replaced by an *real number*. \n",
        "* `6` specifies that a total of 6 characters would be allocated to print out the number. \n",
        "* `.2` displays the real number up to two decimal places\n",
        "* `0` specifies that if the number of characters is less than number of allocated characters (6 in our case), the empty spaces should be replaced with 0."
      ]
    },
    {
      "metadata": {
        "id": "d-MkGingOOxS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "fad9cee0-acee-49d2-f77f-e149b01650b2"
      },
      "cell_type": "code",
      "source": [
        "print('The float value is {:f}'.format(3.141592653589793))\n",
        "print('The float value is {:06.2f}'.format(3.141592653589793))\n",
        "print('The float value is {:6.2f}'.format(3.141592653589793))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The float value is 3.141593\n",
            "The float value is 003.14\n",
            "The float value is   3.14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "ROQm0zCpARR6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "#Section 2: Functions and control structures"
      ]
    },
    {
      "metadata": {
        "id": "M7viXmChOOxk",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Functions\n",
        "Python functions are defined similar to other languages such as C and Java. **However, blocks of codes in Python are organized by how they are indented.** \n",
        "\n",
        "While in languages such as C/C++, Java, JavaScript, C#, Perl, and R, codes are placed within curly brackets (`{}`) to form a block,\n",
        "in Python, codes are considered to be in the same block if they are indented by the same amount of space from the left (unless broken by a higher level block). The figure below gives a simple, easy-to-understand example.\n",
        "\n",
        "![代替テキスト](https://raw.githubusercontent.com/kalngyk/repoman/master/indentation.png)\n",
        "\n",
        "These indentations can be written with spaces or tabs, but the same spaces/tabs must be consistently used for all the codes in the same block.\n",
        "\n",
        "Another important thing to take note is that unlike in other languages, **statements in Python do not end in '`;`'**.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "ifQz_l3ROOxl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Correct way of defining a function\n",
        "def square(num):  \n",
        "    \"Returns the square of a number\"\n",
        "    result = num**2\n",
        "    return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "iURm6A2dOOxm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Note that the function definition ends with a ':' character.**\n",
        "Now that we have defined our function `square`, we can make use of the function to square some numbers."
      ]
    },
    {
      "metadata": {
        "id": "zlXvNUZIOOxm",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = square(2)\n",
        "print(\"{0} times {0} equals {1}\".format(2, x))\n",
        "x = square(2.5)\n",
        "print(\"{0}{0} equals {1}\".format(2.5, x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "d_5VmazJOOxo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The following codes would result in an **IndentationError** since Python does not use curly bracket to define the code block."
      ]
    },
    {
      "metadata": {
        "id": "a6featyzOOxp",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# this will not work. \n",
        "\n",
        "def square(num):\n",
        "{\n",
        "   result = num**2\n",
        "   return result\n",
        "}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "4erJwFYNOOxu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The following codes would result in an **IndentationError** as well."
      ]
    },
    {
      "metadata": {
        "id": "plt6MLy_OOxu",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# This will NOT work.\n",
        "\n",
        "def square(num):\n",
        "    result = num**2\n",
        "return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qtwFabMVOOxx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Functions returning more than one variable\n",
        "\n",
        "Different from most languages, Python functions are allowed to return more than one variable."
      ]
    },
    {
      "metadata": {
        "id": "8kuRPJbEOOxx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def get_square_n_cube(num):\n",
        "    \"Returns the square of a number\"\n",
        "    sq = num**2\n",
        "    cb = num**3\n",
        "    return sq, cb"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UENUJ5dhOOx0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sq, cb = get_square_n_cube(2)\n",
        "print(sq, cb)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "QSKY7TWG78yC",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Variables returned from a function can be selectively ignored, as follows."
      ]
    },
    {
      "metadata": {
        "id": "crDiFCNB77lc",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sq, _ = get_square_n_cube(2)   # ignore the cube\n",
        "print(sq)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "VOuHBxGnOOx2",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Function parameter passing\n",
        "Same as with other languages,  in Python, objects are passed by reference, while **primitive variables** such as `integer`, `double` and `float` as well as **`string`s** are **passed by value**. For example, in the following code, changes to parameters `intval` and `strval` in `func` will not affect the original two variables. "
      ]
    },
    {
      "metadata": {
        "id": "XOyR9_FxOOx2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def func(intval, strval):\n",
        "    intval = 100\n",
        "    strval = \"Modified string value\"\n",
        "    print (\">>> func: numval = {}, strval = {}\".format(intval, strval))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "W7gnFA8YOOx3",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "intval  = 0\n",
        "strval = \"Original string value\"\n",
        "\n",
        "print (\"main (before calling func): numval = {}, strval = {}\".format(intval, strval))\n",
        "func(intval, strval)\n",
        "print (\"main (after calling func): numval = {}, strval = {}\".format(intval, strval))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "2ya9rlIQOOx6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Function default arguments"
      ]
    },
    {
      "metadata": {
        "id": "72ZvgGVNgKzg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Python allows the setting of default arguments in the list of input parameters -- these values will be used when the caller does not specify the values for these parameters.\n",
        "\n",
        "We show this with the following function, which also uses an `if` statement. In Python, an `if` statement must end with the \"`:`\" character, and the entire block of codes to be executed must be indented further to the right.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "x1eMmzErgKFK",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def square(num, rounding=False):\n",
        "    result = num**2\n",
        "    if rounding:\n",
        "        result = int(result)\n",
        "    return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "MrQ_EyZ8OOx7",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(square(2.5))\n",
        "print(square(2.5, rounding=True))\n",
        "print(square(2.5, True))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "1_uyDXdXOOyE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Conditional operators\n",
        "Python only allows the conditional operators: `if` and `elif`. There is no `switch-case` operator in Python.\n",
        "\n",
        "The following code shows the syntax for implementing compound conditions in Python."
      ]
    },
    {
      "metadata": {
        "id": "dpKpqTtROOyH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c9f682e8-7d24-4492-ac2c-98ae815abc67"
      },
      "cell_type": "code",
      "source": [
        "from random import random\n",
        "\n",
        "if random() > .5 and random() > .5:\n",
        "    print('This line gets printed 1/4 of the time')\n",
        "else:\n",
        "    print('This line gets printed 3/4 of the time')"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This line gets printed 3/4 of the time\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "C6zHMJxP-mOd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from random import random\n",
        "\n",
        "if random() > .5 or random() > .5:\n",
        "    print('This line gets printed 3/4 of the time')\n",
        "else:\n",
        "    print('This line gets printed 1/4 of the time')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zNc5Ra4KOOyL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Loops\n",
        "\n",
        "The operator for performing loops in Python is `for` and `while`. Similarly, indentation is used to define the scope for loops. The following example show how to use the `for` loop to iterate a list of integers and strings"
      ]
    },
    {
      "metadata": {
        "id": "bItsuAqfOOyL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for num in [1, 2, 3, 4, 5]:\n",
        "    print(num)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "kzeCvC24OOyN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "74b6dccc-999f-4a9f-d597-770b8ae14dc2"
      },
      "cell_type": "code",
      "source": [
        "for name in ['lessie', 'joe', 'bob']:\n",
        "    print(name)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "lessie\n",
            "joe\n",
            "bob\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "bW04otttOOyQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "42f95520-b98c-42c2-d9f9-3a9e137e0997"
      },
      "cell_type": "code",
      "source": [
        "num = 1\n",
        "while num <= 5:\n",
        "    print(num)\n",
        "    num += 1"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "mhPwNFy9OOyS",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can use the function **`range(end)`** to generate  an iterable sequence of integers starting from 0 up to not including `end`."
      ]
    },
    {
      "metadata": {
        "id": "zuG8fCOMOOyU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for num in range(5):        \n",
        "    print(num) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "omKEe-mxOOyV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can use the function **`range(start, end)`** to generate  an iterable sequence of integers starting from `start` up to `end-1`."
      ]
    },
    {
      "metadata": {
        "id": "fk3CXsI0OOyW",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for num in range(3, 7):     \n",
        "    print(num) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "3FIzbwdYOOyY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can use the function **`range(start, end, skip)`** to generate an iterable sequence of integers starting from start up to end-1 with a resolution of `skip` ."
      ]
    },
    {
      "metadata": {
        "id": "TzWh43aiOOyZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for num in range(10, 26, 5):  \n",
        "    print(num) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Cx3N4H_ROOyb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "When looping a sequence, the position index and corresponding value can be retrieved using the **`enumerate()`** function."
      ]
    },
    {
      "metadata": {
        "id": "u1842rSOOOyd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "for i, v in enumerate(['tic', 'tac', 'toe']):\n",
        "    print(i, v)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "mPm2bb58OOyf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To loop over two or more sequences at the same time, the entries can be paired using the **`zip()`** function."
      ]
    },
    {
      "metadata": {
        "id": "frXzzRgeOOyg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "questions = ['name', 'quest', 'favorite color']\n",
        "answers = ['lancelot', 'the holy grail', 'blue']\n",
        "for q, a in zip(questions, answers):\n",
        "    print ('What is your {0}?  It is {1}.'.format(q, a))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gCQgeN0uOOyh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "18d9ce87-c88e-49df-9a0d-88d3f44ea31f"
      },
      "cell_type": "code",
      "source": [
        "names = ['Krishnan', 'Shafie', 'Kim Loong']\n",
        "grades = [99, 100, 89]\n",
        "\n",
        "for n, g in zip(names, grades):\n",
        "    print('{0}: {1}.'.format(n, g))"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Krishnan: 99.\n",
            "Shafie: 100.\n",
            "Kim Loong: 89.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "1s7hW55qOOyw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "#Section 3: Built-in data structures\n",
        "\n",
        "Python comes equipped with some useful built-in data structures. They include\n",
        "* List\n",
        "* Tuple\n",
        "* Set\n",
        "* Dictionary"
      ]
    },
    {
      "metadata": {
        "id": "Dc3WeauW0bGE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "## List\n",
        "\n",
        "A list is the simplest, most flexible and arguably the most frequently used  data structure in Python. It stores a sequence of mutable (changeable) items of possibly different types.\n",
        "\n",
        "**Create a new list**:"
      ]
    },
    {
      "metadata": {
        "id": "343ww6JtOOyw",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "fruits = ['apple', 'orange', 'pear']   # a list of strings\n",
        "print(fruits)\n",
        "\n",
        "numbers = [11, 12, 13, 14]             # a list of integers\n",
        "print(numbers)\n",
        "\n",
        "isHandsome = [True, False, True]       # a list of booleans\n",
        "print(isHandsome)\n",
        "\n",
        "rojak = [11, 'hello', True, [1,2,3], ['one', 2, False]]     # a list of different types of items\n",
        "print(rojak)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "hRALLCMWOOyx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Get the length of a list**:"
      ]
    },
    {
      "metadata": {
        "id": "7gXVTu_ZOOyy",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "len(numbers)   "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JQ_BPrjlOOy1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Iterate all items in a list**:"
      ]
    },
    {
      "metadata": {
        "id": "t0_Tv9LbOOy1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "numbers = [11, 12, 13, 14]\n",
        "for x in numbers:\n",
        "    print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "c6E0BZDbOOy3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Unpack the values in a list into individual variables:** "
      ]
    },
    {
      "metadata": {
        "id": "tENSY0EvOOy3",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "a, b, c = fruits\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vAR56-JeOOy5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Concatenate multiple lists**\n",
        "\n",
        "Use the `+` operator to do list concatenation:"
      ]
    },
    {
      "metadata": {
        "id": "j2g2L_JtOOy5",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "fruits = ['apple', 'orange', 'pear']\n",
        "print(fruits)\n",
        "\n",
        "otherFruits = ['kiwi', 'strawberry']\n",
        "print(otherFruits)\n",
        "\n",
        "allFruits = fruits + otherFruits\n",
        "print(allFruits)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "G6NCThx6OOy8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Access a specific item in the list**:"
      ]
    },
    {
      "metadata": {
        "id": "jKyjaqniOOy8",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "fruits[0]            # first item of fruits"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9TNKlRaZOOy-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "fruits[0] = 'durian'\n",
        "fruits"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zGXoZqntOOzD",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "rojak[3]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "GyhxhlcqOOzG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "rojak[3] = 'new item'\n",
        "rojak"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JqIEQnmOOOzH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Slice indexing (creating a sublist):**\n",
        "\n",
        "We can index multiple adjacent elements using the slice operator. For instance, `fruits[1:3]` returns a list containing the elements at position 1 and 2. In general `fruits[start:stop]` will get the elements in `start`, `start`+1, ..., `stop`-1. We can also do `fruits[start:]` which returns all elements starting from the start index. Also `fruits[:end]` will return all elements before the element at position end:"
      ]
    },
    {
      "metadata": {
        "id": "IhiqZ6xJOOzH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(allFruits)    # print all items\n",
        "\n",
        "print(allFruits[0:2])  # items 0 and 1 (not including 2)\n",
        "print(allFruits[:3])   # first item to item 2 (not including 3)\n",
        "print(allFruits[2:])   # items 2 to last item"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JvTn1y9ROOzI",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Negative indexing:**\n",
        "\n",
        "Python also allows negative-indexing from the back of the list. For instance, `allfruits[-1]` will access the last element `'strawberry'`:"
      ]
    },
    {
      "metadata": {
        "id": "yBPLSC6qOOzJ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(allFruits)\n",
        "allFruits[-1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "3WVEEVu-OOzK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The following codes combine negative indexing and slice indexing"
      ]
    },
    {
      "metadata": {
        "id": "NJygVF-7OOzK",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "allFruits[-3:]       # Start from the third last item to the end of the list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UFvjTbrIOOzO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "allFruits[-3:-1]     # Start from the third last item to the second last item of the list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "c4t8E_xlOOzP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Reference copy of a list:**\n",
        "\n",
        "For list, the assignment operator `=` only copy the address of the source. This means that it is *pointing* or *referencing* to the same object as the source. \n",
        "\n",
        "For example:"
      ]
    },
    {
      "metadata": {
        "id": "KnfXWn8XOOzR",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "colors1 = [\"red\", \"green\"]\n",
        "colors2 = colors1\n",
        "print('colors1 = ', colors1)\n",
        "print('colors2 = ', colors2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qNeQh3dWOOzR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The above results in the following structure:\n",
        "\n",
        "![shallowcopy1](https://raw.githubusercontent.com/kalngyk/repoman/master/referencecopy.png)\n",
        "\n",
        "Since they point to the same list, any changes to either `color1` or `color2` would affect the other."
      ]
    },
    {
      "metadata": {
        "id": "aVKaqbbEOOzR",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print('Changing colors2 second element to blue')\n",
        "colors2[1] = 'blue'            # changing the content of the second item in colors2\n",
        "\n",
        "print ('colors1 = ', colors1)  # colors1 changes too because of shallow copy\n",
        "print ('colors2 = ', colors2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "C8JiijRiOOzU",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Shallow copy of a list:**\n",
        "\n",
        "The method `.copy()` performs a shallow copy where only the content of the shallowest level are copied. "
      ]
    },
    {
      "metadata": {
        "id": "_M7oFbMjOOzV",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "list1 = ['a', 'b', ['ab', 'ba']]    # list is shallow - contains only one level\n",
        "list2 = list1.copy()                # copy list\n",
        "print(list1)\n",
        "print(list2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Ifog7tuFOOzW",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The above command results in the following structure:\n",
        "\n",
        "![shallowcopy](https://raw.githubusercontent.com/kalngyk/repoman/master/shallowcopy.png)"
      ]
    },
    {
      "metadata": {
        "id": "dRLiLSRMOOzW",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "From the figure, it is easy to see why changing the content of the shallow items of one array would not have affect the other array. But, any changes to non-shallow items will affect both arrays"
      ]
    },
    {
      "metadata": {
        "id": "ruM6eGmYOOzW",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "list2[1] = 'x'      # changing a shallow item in list 2  will not affect list1\n",
        "list2[2][1] = 'zz'  # changing a non-shallow item in list2 will also affect list1\n",
        "print(list1)\n",
        "print(list2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Hl6fclJnOOzY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Deep copy of list:**\n",
        "\n",
        "To copy the entire structure, we can use the module function `copy.deepcopy`."
      ]
    },
    {
      "metadata": {
        "id": "CY7WU6TrOOzZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from copy import deepcopy\n",
        "\n",
        "lst1 = ['a','b',['ab','ba']]\n",
        "lst2 = deepcopy(lst1)   # slice copying\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "F9Popq8lOOzb",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "lst2[0] = 'c'\n",
        "lst2[2][1] = 'd'\n",
        "print('lst1: ', lst1)\n",
        "print('lst2: ', lst2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "7mb62gPfOOzc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### List comparison\n",
        "There are two operators for comparison in Python: `==` and `is`. \n",
        "\n",
        "The operator `is` checks if two variables are referencing the same list or object, while the operator `==` checks if the lists have the same content.\n",
        "\n",
        "For *reference copy*, both `is` and `==` return `True` because they references the same list or object."
      ]
    },
    {
      "metadata": {
        "id": "ZST-3nKkOOze",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "b = a\n",
        "print(b is a)\n",
        "print(b == a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "wMWUvbVKOOzf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "For *shallow copy* and *deep copy*,\n",
        "* `is` returns `False` because they are pointing to different lists or objects.\n",
        "* `==` returns `True` because their content are the same."
      ]
    },
    {
      "metadata": {
        "id": "SMxoHXclOOzf",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "b = a.copy()\n",
        "print(b is a)\n",
        "print(b == a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "aFbQIuJaOOzg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from copy import deepcopy\n",
        "c = deepcopy(a)\n",
        "print(b is a)\n",
        "print(b == a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "nosy-jlAOOzi",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Quick reference to useful functions for list\n",
        "\n",
        "**`list.append(x)`**: Add an item to the end of the list; equivalent to `a[len(a):] = [x]`<br>\n",
        "**`list.extend(x)`**: Extend the list by appending all the items in the given list; equivalent to `a[len(a):] = L`.<br>\n",
        "**`list.insert(i, x)`**: Insert the item x at position i. The first argument is the index of the element before which to insert, so `a.insert(0, x)` inserts at the front of the list, and `a.insert(len(a), x)` is equivalent to `a.append(x)`.<br>\n",
        "**`list.remove(x)`**: Remove the first item from the list whose value is `x` . It is an error if there is no such item.<br>\n",
        "**`list.pop(i)`**: Remove the item at the given position in the list, and return it. If no index is specified, `a.pop()` removes and returns the last item in the list.<br>\n",
        "**`list.index(x)`**: Return the index in the list of the first item whose value is `x`. It is an error if there is no such item.<br>\n",
        "**`List.count(x)`**: Return the number of times `x` appears in the list.<br>\n",
        "**`list.sort(key=None, reverse=False)`**: Sort the items of the list in place.<br>\n",
        "**`list.reverse()`**: Reverse the elements of the list, in place.<br>\n",
        "**`len(list)`**: Returns the number of items in the sequence.<br>\n",
        "**`min(list)`**: Returns the smallest item in the sequence.<br>\n",
        "**`max(list)`**: Returns the biggest item in the sequence.<br>\n",
        "**`any(list)`**: Returns `True` if there exists an item in the sequence which is `True`.<br>\n",
        "**`all(list)`**: Returns `True` if all items in the seuqnece are True.<br>\n"
      ]
    },
    {
      "metadata": {
        "id": "HtTgCpqxOOzn",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Tuple\n",
        "\n",
        "A tuple is a data structure that is similar to the list except that it is immutable once it is created, i.e., you cannot change its content once created. It takes up less memory for the same number of items compared to list. So, it is advisable to use tuples compared to list if possible. \n",
        "\n",
        "To **create a tuple**, use a parentheses rather than a square brackets."
      ]
    },
    {
      "metadata": {
        "id": "mwJdfgKuOOzn",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pair = (3,5)\n",
        "print(pair)\n",
        "print(pair[0])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "7AjU_nl3OOzr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The attempt to modify an immutable structure will raise an exception. Exceptions indicate errors: index out of bounds errors, type errors, and so on will all report exceptions in this way."
      ]
    },
    {
      "metadata": {
        "id": "F9Onj6S-OOzr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pair[1] = 6"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "84Rj4ukDOOzr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Set\n",
        "\n",
        "A set is like a list, but allows **no duplicate items**. Common set operations (difference, intersection, union) are available for the data structure.\n",
        "\n",
        "**Create a new set from list**:"
      ]
    },
    {
      "metadata": {
        "id": "LoDck_65OOzr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "user_selected_shapes = ['circle', 'square', 'triangle', 'circle']\n",
        "shapes = set(user_selected_shapes)\n",
        "shapes"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "awEbRqdGOOzs",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Insert new items into a set**:"
      ]
    },
    {
      "metadata": {
        "id": "OlcPRk3MOOzs",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Adding pentagon\")\n",
        "shapes.add('pentagon') \n",
        "print(shapes)\n",
        "print(\"Adding circle\")\n",
        "shapes.add('circle')\n",
        "print(shapes)\n",
        "print(\"Adding triangle\")\n",
        "shapes.add('triangle')\n",
        "print(shapes)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rlzWWU9vOOzx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Check if exist in set**:"
      ]
    },
    {
      "metadata": {
        "id": "w-dJZCazOOzx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "if 'circle' in shapes:\n",
        "    print('circle exists in shapes')\n",
        "else:\n",
        "    print('circle does not exist in shapes')\n",
        "    \n",
        "if 'rhombus' in shapes:\n",
        "    print('rhombus exists in shapes')\n",
        "else:\n",
        "    print('rhombus does not exist in shapes')\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "hexl9ccGOOzy",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Operations on set**:\n",
        "\n",
        "The following shows how to perform intersection (`&`), union (`|`) and deletion (`-`) operation on two sets."
      ]
    },
    {
      "metadata": {
        "id": "fFBhg8DVOOzz",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "polygons = set(['triangle', 'square', 'hexagon', 'pentagon'])\n",
        "print ('shapes:   ', shapes)\n",
        "print ('polygons: ', polygons)\n",
        "print ()\n",
        "\n",
        "print('shapes minus polygons:', shapes - polygons)\n",
        "print('shapes intersect polygons:', shapes & polygons)\n",
        "print('shapes union polygons:', shapes | polygons)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IGk6izvIOOz1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Dictionary\n",
        "\n",
        "The dictionary is arguably the second most commonly used data structure in Python. A dictionary stores a map from one type of object (the `key`) to another (the `value`). \n",
        "* The `key` must be of an immutable type (string, number, or tuple). \n",
        "* The `value` can be of any Python data type (objects, lists, dictionaries, etc).\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "HqZ_DaY_L5xh",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Creating a dictionary**:\n",
        "\n",
        "There are many ways to create a dictionary. \n",
        "The standard way is to use the curly bracket `{}`."
      ]
    },
    {
      "metadata": {
        "id": "HYPvz_xvOOz1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "studentIds = {'joe': 10491, 'mary': 10489}\n",
        "studentIds"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eyt3dmtBOOz3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Another way is to pass a list of tuples to the dict constructor:"
      ]
    },
    {
      "metadata": {
        "id": "2Qg1ibq4OOz3",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "d1 = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n",
        "d1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "6hmsFWzDOOz5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "Yet another way is to pass keyword arguments to the dict constructor:"
      ]
    },
    {
      "metadata": {
        "id": "gJl3ft3FOOz5",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "d2 = dict(sape=4139, guido=4127, jack=4098)\n",
        "d2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fI7E_g6yOOz6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Lastly, you can also use two different lists, one for keys and the other for values. Then, we can construct the dictionary using list comprehensions (which we will cover next)."
      ]
    },
    {
      "metadata": {
        "id": "46bJOThGOOz6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "namelist = ['joe', 'mary']\n",
        "ids = [10491, 10489]\n",
        "d3 = {name: age for name, age in zip(namelist, ids)}   # list comprehension\n",
        "d3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "w0sNnmEMOOz8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Indexing an item in dictionary**:"
      ]
    },
    {
      "metadata": {
        "id": "jzry1JJrOOz8",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "studentIds = {'joe': 42.0, 'mary': 56.0}\n",
        "print (studentIds)\n",
        "\n",
        "# accessing the item with key 'mary'\n",
        "print(studentIds['mary'])\n",
        "\n",
        "\n",
        "# Changing the item with key 'mary'\n",
        "studentIds['mary'] = 100\n",
        "print(studentIds)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "W25KrW6ROOz-",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Adding an item in dictionary**:"
      ]
    },
    {
      "metadata": {
        "id": "NylNOSLfOOz-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "studentIds['ali'] = 92.0\n",
        "studentIds"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "kqWbS9QNOOz_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**The values can be of different types**:"
      ]
    },
    {
      "metadata": {
        "id": "sn2kHHnwOOz_",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "studentIds['joe'] = 'forty-two'         # string type\n",
        "print(studentIds)\n",
        "\n",
        "studentIds['ali'] = [42.0,'forty-two']  # list type\n",
        "print(studentIds)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "CVQcJVh3OO0B",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Getting the size of a dictionary**:"
      ]
    },
    {
      "metadata": {
        "id": "D67GwX9KOO0B",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "len(studentIds)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "EkVMWEzvOO0C",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Accessing the keys and values in dictionary**:\n",
        "\n",
        "*(Note that the order of the keys returned may be different from the order in which the keys are created.)*"
      ]
    },
    {
      "metadata": {
        "id": "vSqAj-woOO0C",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(studentIds.keys())\n",
        "print(studentIds.values())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_w6swSvYOO0G",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Converting the dict_keys and dict_values directly to list**:"
      ]
    },
    {
      "metadata": {
        "id": "P1hO42x1OO0H",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(list(studentIds.keys()))\n",
        "for k in list(studentIds.keys()):\n",
        "    print(k)\n",
        "\n",
        "print(list(studentIds.values()))\n",
        "for v in list(studentIds.values()):\n",
        "    print(v)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "s4BvmBX2OO0I",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Accessing items, keys and values in a dictionary**:\n",
        "\n",
        "* `<dictionary>.items()` is an iterable object. When used with `for`, it iterates through the list of all *items* in `dictionary`, returning one item at a time. Each item is a tuple  `(key, value)`.\n",
        "* `<dictionary>.keys()` is an iterable object. When used with `for`, it iterates through the *keys* of all items in `dictionary`, returning one key at a time. \n",
        "* `<dictionary>.values()` is an iterable object. When used with `for`, it iterates through the *values* of all items in `dictionary`, returning one value at a time. "
      ]
    },
    {
      "metadata": {
        "id": "UX2qEy7vOO0I",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print('All items in studentIds: ')\n",
        "for item in studentIds.items(): \n",
        "    print (item[0], ':', item[1])   # item[0] is the key, item[1] is the value\n",
        "\n",
        "print('\\nThe keys of all items in studentIds: ')\n",
        "for key in studentIds.keys():\n",
        "    print (key)\n",
        "\n",
        "print('\\nThe values of all items in studentIds: ')\n",
        "for value in studentIds.values():\n",
        "    print (value)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "pMrmR1h3OO0J",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Removing an item from dictionary**:"
      ]
    },
    {
      "metadata": {
        "id": "RpRjJiujOO0J",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "del studentIds['joe']\n",
        "studentIds"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "L_eIU6i_OO0K",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "As with nested lists, you can also create dictionaries of dictionaries."
      ]
    },
    {
      "metadata": {
        "id": "UCohV_YbOO0Q",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "# Section 4: Advanced constructs\n",
        "Python allows many advanced constructs. In this section we discuss\n",
        "- List comprehension\n",
        "- Function as variable"
      ]
    },
    {
      "metadata": {
        "id": "un7gh-yaRAMI",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##List comprehension\n",
        "List comprehension provides a concise way to operate on a list to create a new list.\n",
        "\n",
        "Suppose you want to create a list of squares. You might do this as follows:"
      ]
    },
    {
      "metadata": {
        "id": "_tJhBcwVOO0R",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "nums = [1, 3, 5, 7, 11, 13, 17]\n",
        "squares = []\n",
        "for n in nums:\n",
        "    squares.append(n**2)\n",
        "print(squares)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vIRXZ3ErOO0T",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "List Comprehension can help you represent the loop more concisely as follows:"
      ]
    },
    {
      "metadata": {
        "id": "Xio4xy7uOO0U",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "squares2 = [x**2 for x in nums]\n",
        "print(squares2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JcarCKaEOO0V",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can also do filtering on the items that you want to operate on. Let's say we want to extract only odd numbers from  a list and then multiply all of them by 100:"
      ]
    },
    {
      "metadata": {
        "id": "bozyzLi6OO0V",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7]\n",
        "result = [x*100 for x in nums if x % 2 == 1]\n",
        "print (result)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "6u0Mo1_WU9Sj",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Another convenient use of list comprehension is to generate a list of pairwise tuples of the original list."
      ]
    },
    {
      "metadata": {
        "id": "PuwMBUEUVGrH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pairs = [(x, y) for x in nums for y in nums]\n",
        "pairs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "P0dvL-y6Ipf1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Together with functions such as `zip` and `enumerate`, list comprehension allows us to accomplish in a single line some complex operations.\n",
        "\n",
        "The use of `zip` has been demonstrated in the construction of dictionary, here, we show how `enumerate` allows us to easily obtain the indices of the elements in a list which fulfills a given condition."
      ]
    },
    {
      "metadata": {
        "id": "sns-4utNIpf4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7]\n",
        "where_odd = [i for (i, y) in enumerate(nums) if y % 2 == 1]\n",
        "print(where_odd)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "QBmRIkrcMMy1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##Function as variable\n",
        "Functions can be assigned to variables as well as passed as parameters to other functions in Python (similar to function pointers in C/C++).\n",
        "\n",
        "For instance, Python has an in-built sort function called `sorted` which has the capability to sort a list of **objects** (as opposed to primitive values). The function `sorted` accepts another function as one of its input parameters -- the input function informs `sorted` on how to compute the values to use for sorting.\n",
        "\n",
        "In this example, we use `sorted` to sort a list of strings by their last two characters.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "zJ8Axm-JXxiA",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def last2chars(str):\n",
        "    return str[-2:]\n",
        "\n",
        "strings = [\"xfile05\", \"yfile02\", \"zfile01\", \"wfile06\", \"vfile03\"]\n",
        "\n",
        "sorted(strings, key=last2chars)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vFGBZZRrZ1v5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Python allows the definition of unnamed functions through the `lambda` keyword. Using the `lambda`, the above codes can be rewritten as:"
      ]
    },
    {
      "metadata": {
        "id": "vi3Xym3JZ1Qu",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "sorted(strings, key=lambda x: x[-2:])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "YFmEsdr5aY16",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Together with the `map` and `filter` function, the use of the `lambda` keyword allows us to write concise codes that operate on lists to create new lists. \n",
        "This provides an alternative to list comprehension.\n",
        "\n",
        "For instance, we can create a list which consists of the squared values of another list as follows."
      ]
    },
    {
      "metadata": {
        "id": "C4WDrPiAMNE0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "nums = [1, 3, 5, 7, 11, 13, 17]\n",
        "# The following does the same thing as \"squares2 = [x**2 for x in nums]\"\n",
        "squares2 = list(map(lambda x: x**2, nums))\n",
        "squares2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "y_W1BMH2b83J",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We can similarly filter out values from another list as follows."
      ]
    },
    {
      "metadata": {
        "id": "YVgrkJjtb9SB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a131c804-40d0-49fe-d4e3-0eeef04091f1"
      },
      "cell_type": "code",
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7]\n",
        "# The following does the same thing as \"result = [x*100 for x in nums if x % 2 == 1]\"\n",
        "result = list(map(lambda x: x*100, filter(lambda x: x % 2 == 1, nums)))\n",
        "result"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[100, 300, 500, 700]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "metadata": {
        "id": "Dx58g5pQdcyr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "However, in such cases, the list comprehension way appears to be clearer, and is the preferred method to the creator of Python, Guido Rossum."
      ]
    },
    {
      "metadata": {
        "id": "lrgY1NZlJBas",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Closing remarks\n",
        "\n",
        "This tutorial has barely scratched the surface of the features in Python. You are advised to study on your own at least the following topics:\n",
        "- Python classes, which allows the creation of new types of objects.\n",
        "\n",
        "- The `numpy` module, which provides an `numpy.ndarray` data structure which is much more powerful than Python lists.\n",
        "\n",
        "You can find a more complete tutorials at\n",
        "- https://docs.python.org/3/tutorial/index.html\n",
        "- http://cs231n.github.io/python-numpy-tutorial/"
      ]
    }
  ]
}