Python_Loops.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Loops.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "lftlrceMeClR",
        "WCjQDt3_lCxz"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ialimustufa/python-crash-course/blob/master/Python_Loops.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSVI7V3vMMpX",
        "colab_type": "text"
      },
      "source": [
        "# **Loops:**\n",
        "In general, statements are executed sequentially. The first statement in a function is executed first, followed by the second, and so on.\n",
        "\n",
        "There may be a situation when you need to execute a block of code several number of times\n",
        "A loop statement allows us to execute a statement or group of statements multiple times. \n",
        "\n",
        "In Python, there are three loops:\n",
        "\n",
        "1.  While\n",
        "2.  For\n",
        "3.  Nested"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CdrL8DsGJ0Cc",
        "colab_type": "text"
      },
      "source": [
        "**While loop:**\n",
        "\n",
        "Here, first the condition is checked and if it’s true, control will move inside the loop and execute the statements inside the loop until the condition becomes false. We use this loop when we are not sure how many times we need to execute a group of statements or you can say that when we are unsure about the number of iterations."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N2aeOTRWJvXG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "outputId": "fe90d71d-caaf-48c0-f7a1-986cdc7cdb4d"
      },
      "source": [
        "count = 0\n",
        "while (count < 10):\n",
        "                print ( count )\n",
        "                count += 1\n",
        " \n",
        "print (\"While loop end\")\n",
        "print (count)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "While loop end\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W42i-o-cMRXz",
        "colab_type": "text"
      },
      "source": [
        "**For Loop:** \n",
        "\n",
        "Like the While loop, the For loop also allows a code block to be repeated certain number of times. The difference is, in For loop we know the amount of iterations required unlike While loop, where iterations depends on the condition. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tqiSire4MTaN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "09f2248a-46c1-47e3-d23c-151ae9289a5f"
      },
      "source": [
        "food = ['Spinach', 'Mango', 'Tomato'] # Iterate through the elements in the Lists\n",
        "\n",
        "for i in range(len(food)):\n",
        "                          print (food[i])\n",
        "                          "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Spinach\n",
            "Mango\n",
            "Tomato\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xsPwuCc2Rx_o",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6b30d51b-ccf4-45a8-acfb-b6dd9d5c161c"
      },
      "source": [
        "food = ['Spinach', 'Mango', 'Tomato'] \n",
        "print (food[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mango\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eOvCa_YCNuOv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c9baf5e6-b6fe-4642-be8f-2a5c4ec4205a"
      },
      "source": [
        "family = {'Dad':'Goku', 'Mom':'Chichi', 'No. of Children':2} # iterate through two things at once (using tuple )\n",
        "for key, value in family.items():\n",
        "    print(key, value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dad Goku\n",
            "Mom Chichi\n",
            "No. of Children 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AufenN-nOkym",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c8fafa14-3c80-406b-f3c3-2f0199b74662"
      },
      "source": [
        "#An example of for-each loop\n",
        "food = ['Spinach', \"Tomato\",\"Mango\"] \n",
        "for i in food:\n",
        "    if i == 'Mango':\n",
        "        m = 1\n",
        "        print('Found Mango!')\n",
        "            # exit the loop and skip the 'else' block\n",
        "        break\n",
        "else :\n",
        "    print(\"Can't find Mango\")  \n",
        "\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Can't find Mango\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "POX1jpBnRMup",
        "colab_type": "text"
      },
      "source": [
        "**Nested Loops**\n",
        "\n",
        "A nested loop is a loop inside a loop.\n",
        "\n",
        "The \"inner loop\" will be executed one time for each iteration of the \"outer loop\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "72iV-7CyRWuJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        },
        "outputId": "71285a34-ce18-434c-fb45-0a7e297b61e5"
      },
      "source": [
        "colour = [\"Red\", \"Yellow\", \"Green\"]\n",
        "fruits = [\"Apples\", \"Mangoes\", \"Grapes\"]\n",
        "\n",
        "for x in colour:\n",
        "  for y in fruits:\n",
        "      print(x +\" -\", y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Red - Apples\n",
            "Red - Mangoes\n",
            "Red - Grapes\n",
            "Yellow - Apples\n",
            "Yellow - Mangoes\n",
            "Yellow - Grapes\n",
            "Green - Apples\n",
            "Green - Mangoes\n",
            "Green - Grapes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t-YNe2y5aLE-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "db559a76-3976-45bd-cf57-81d66b8bb6d5"
      },
      "source": [
        "colour = [\"Red\", \"Yellow\", \"Green\"]\n",
        "fruits = [\"Apples\", \"Mangoes\", \"Grapes\"]\n",
        "\n",
        "\n",
        "for x,y in zip(range(len(colour)), range(len(fruits))) :\n",
        "    print(colour[x],fruits[y])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Red Apples\n",
            "Yellow Mangoes\n",
            "Green Grapes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3oXw24ZMR51_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 323
        },
        "outputId": "bca19e58-ab9b-488e-ac0f-78d63bead8d8"
      },
      "source": [
        "colour = [\"Red\", \"Yellow\", \"Green\"]\n",
        "fruits = [\"Apples\", \"Mangoes\", \"Grapes\"]\n",
        "surface = [\"Smooth\", \"Rough\"]\n",
        "\n",
        "for x in colour:\n",
        "  for y in fruits:\n",
        "      for z in surface:\n",
        "        print(x +\" -\", y +\" -\", z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Red - Apples - Smooth\n",
            "Red - Apples - Rough\n",
            "Red - Mangoes - Smooth\n",
            "Red - Mangoes - Rough\n",
            "Red - Grapes - Smooth\n",
            "Red - Grapes - Rough\n",
            "Yellow - Apples - Smooth\n",
            "Yellow - Apples - Rough\n",
            "Yellow - Mangoes - Smooth\n",
            "Yellow - Mangoes - Rough\n",
            "Yellow - Grapes - Smooth\n",
            "Yellow - Grapes - Rough\n",
            "Green - Apples - Smooth\n",
            "Green - Apples - Rough\n",
            "Green - Mangoes - Smooth\n",
            "Green - Mangoes - Rough\n",
            "Green - Grapes - Smooth\n",
            "Green - Grapes - Rough\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qL9d3LlXdVsO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "46096ef9-dade-4eca-eb94-e77812f521f4"
      },
      "source": [
        "colour = [\"Red\", \"Yellow\", \"Green\"]\n",
        "fruits = [\"Apples\", \"Mangoes\", \"Grapes\"]\n",
        "surface = [\"Smooth\", \"Rough\", \"Soft\"]\n",
        "\n",
        "for x,y,z in zip(range(len(colour)), range(len(fruits)), range(len(surface))) :\n",
        "    print(colour[x],fruits[y],surface[z])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Red Apples Smooth\n",
            "Yellow Mangoes Rough\n",
            "Green Grapes Soft\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SjK_B6HHSg-S",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "18a88831-4550-4f40-8884-2f2cbc096ea9"
      },
      "source": [
        "#Matrix Example\n",
        "# for loop to flatten a 2d-matrix\n",
        "matrix = [[1, 2], [3, 4]]\n",
        "matrix2 = []\n",
        "for i in matrix:\n",
        "    for j in i:\n",
        "        matrix2.append(j)\n",
        "print (matrix2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_6csInMk5uoH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "d90ed92f-d51a-429f-f69c-483e85ad51ee"
      },
      "source": [
        "# populate a dictionary using a for loop\n",
        "name = ['Naruto', 'Ryuzaki', 'Vegeta', 'Kuroko', 'Zoro', 'Hina']\n",
        "weight = [15, 18, 17, 30, 25, 23]\n",
        "dictionary = {}\n",
        "\n",
        "for i in range(0,6):\n",
        "    dictionary[name[i]] = weight[i]\n",
        "\n",
        "dictionary"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Hina': 23,\n",
              " 'Kuroko': 30,\n",
              " 'Naruto': 15,\n",
              " 'Ryuzaki': 18,\n",
              " 'Vegeta': 17,\n",
              " 'Zoro': 25}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvDGp4TRYNjk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 191
        },
        "outputId": "6d16ee28-9e53-4596-c4be-c6302e48980d"
      },
      "source": [
        "# Lets print some shapes to get comfortable with loops\n",
        "\n",
        "# pyramid\n",
        "for i in range(10):\n",
        "    print((10-i)*' ' + i*'* ')\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "          \n",
            "         * \n",
            "        * * \n",
            "       * * * \n",
            "      * * * * \n",
            "     * * * * * \n",
            "    * * * * * * \n",
            "   * * * * * * * \n",
            "  * * * * * * * * \n",
            " * * * * * * * * * \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DcmrF2TkulGA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 191
        },
        "outputId": "dbb76a73-cb0d-4156-f6b2-dad45a8c20bc"
      },
      "source": [
        "# half diamond\n",
        "for i in range(10):\n",
        "    if i < 6:\n",
        "        print(i*' *')\n",
        "    else:\n",
        "        print((10 - i)*' *')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            " *\n",
            " * *\n",
            " * * *\n",
            " * * * *\n",
            " * * * * *\n",
            " * * * *\n",
            " * * *\n",
            " * *\n",
            " *\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u64LQwaoY3sn",
        "colab_type": "text"
      },
      "source": [
        "# **Functions:**\n",
        "\n",
        "Functions are a convenient way to divide your code into useful blocks, allowing us to order our code, make it more readable, reuse it and save some time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41Sl4Q_RZOqY",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with no arguments and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7lPlGuNiY_xP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_text():\n",
        "    print('this is text')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_9uSsLHPZKi5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ccafa6df-ef75-45e4-e6e5-8e1939771963"
      },
      "source": [
        "# call the function\n",
        "print_text()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "this is text\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2iYTL18xZS6Q",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with one argument and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vo-cD2OxZUuB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_this(x):\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7D16LaH5ZWHY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "79b32571-d094-41b2-cc0d-e1f85741ae6d"
      },
      "source": [
        "# call the function\n",
        "print_this(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35bK9N-FZbsg",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with one argument and one return value:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z1jqUXCiZfk5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7173699b-fee4-4388-838f-dc5ed904a0ba"
      },
      "source": [
        "def square(x):\n",
        "    return x**2\n",
        "square(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ne0NdmCn5ul9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Example\n",
        "\n",
        "def calc(a, b, op='add'):\n",
        "\n",
        "    if op == 'add':\n",
        "        return a + b\n",
        "\n",
        "    elif op == 'sub':\n",
        "        return a - b\n",
        "        \n",
        "    else:\n",
        "        print('valid operations are add and sub')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hH_4MlBcaOjZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "14253348-7ae7-419c-80d0-2a30885cbad9"
      },
      "source": [
        "# call the function\n",
        "calc(10, 4, op='add')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6yJj0Zr4af0w",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0008db64-99e9-495d-bae4-f9227f322e73"
      },
      "source": [
        "# unnamed arguments are inferred by position\n",
        "calc(10, 4, 'add')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yy-kreh6agU4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ea6bdf09-47e6-4656-eab6-a57246940674"
      },
      "source": [
        "# default for 'op' is 'add'\n",
        "calc(10, 4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TnLSMIGeahaZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c7796064-8c36-4306-856b-aead947e65f7"
      },
      "source": [
        "calc(10, 4, 'sub')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J-VXN_PKasK5",
        "colab_type": "text"
      },
      "source": [
        "**Use pass as a placeholder if you haven't written the function body:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TwMQFziQatdI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stub():\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8XwkxOYsayA5",
        "colab_type": "text"
      },
      "source": [
        "**Return two values from a single function:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lMkT5MqKa5vg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def min_max(nums):\n",
        "    return min(nums), max(nums)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4kGkSJ4Aa9Lo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8668913a-6814-4fbc-ba3b-159071e0021d"
      },
      "source": [
        "# return values can be assigned to a single variable as a tuple\n",
        "nums = [1, 2, 3]\n",
        "output = min_max(nums)\n",
        "output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lftlrceMeClR",
        "colab_type": "text"
      },
      "source": [
        "# **Anonymous Functions (Lambda Functions)**\n",
        "Primarily used to temporarily define a function for use by another function.\n",
        "* Anonymous\n",
        "* Single use, simple 1=line function\n",
        "* Throw-away functions\n",
        "\n",
        "**Syntax :**\n",
        "\n",
        "`lambda arguments : expression`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DuIye2TkeK_R",
        "colab_type": "text"
      },
      "source": [
        "**Here are some single-argument Lambdas:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oTZQdaT9enQi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1469c5b7-bc25-4a92-8969-f0427f2a5266"
      },
      "source": [
        "add10 = lambda x : x + 10\n",
        "print (add10(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HS2ZWAjsezaS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f6863170-8a07-47ba-9572-34ec5a2ba015"
      },
      "source": [
        "square = lambda x : x * x\n",
        "print (square(10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XdZhPXI_f736",
        "colab_type": "text"
      },
      "source": [
        "**Sorting a List of Tuples using Lambda**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ApvFOgRhf01h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ec17bfad-41bd-428a-e858-55bc10a335f3"
      },
      "source": [
        "List = [('carrots', 20), ('potatoes', 50), ('cabbage', 25), ('peas', 15)]\n",
        "\n",
        "List.sort (key = lambda x : x[0])\n",
        "print (List)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[('cabbage', 25), ('carrots', 20), ('peas', 15), ('potatoes', 50)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6QEfcDqqhOkK",
        "colab_type": "text"
      },
      "source": [
        "**Sorting a list of Dictionaries using Lambda**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_CtKVqjRg99i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        },
        "outputId": "d9c197e2-ef10-484a-c93f-ae300c1a9e0b"
      },
      "source": [
        "List1 = [{'Game': 'GTA5', 'Company': 'Rockstar Games', 'Year': 2013} , {'Game': 'Jump Force', 'Company': 'Bandai Namco', 'Year': 2018} , {'Game': 'Fortnite', 'Company': 'Epic Games', 'Year': 2017}]\n",
        "Output = []\n",
        "Output = sorted (List1, key = lambda x : x['Company'])\n",
        "print (Output)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[{'Game': 'Jump Force', 'Company': 'Bandai Namco', 'Year': 2018}, {'Game': 'Fortnite', 'Company': 'Epic Games', 'Year': 2017}, {'Game': 'GTA5', 'Company': 'Rockstar Games', 'Year': 2013}]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WCjQDt3_lCxz",
        "colab_type": "text"
      },
      "source": [
        "# **Map, Filter and Reduce**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eCGX6IOlbkj",
        "colab_type": "text"
      },
      "source": [
        "**Map Function**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eB_Xcx85lNY6",
        "colab_type": "text"
      },
      "source": [
        "The Map function `map()` :\n",
        "\n",
        "*   Applies a function to every element of a sequence \n",
        "*   Returns the modified list\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x5MD2wD85unn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "3fa572e2-4a35-4205-fda0-0c214584b0d5"
      },
      "source": [
        "L1 = ['Unity', 'Unreal', 'Godot']\n",
        "mapping = (map(len, L1)) #where len is the function and L1 is the list name which are the parameters of the map function \n",
        "for i in mapping: \n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "6\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7f02NRxioiQS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "361d4845-c40b-442e-b2bd-b79178a88f55"
      },
      "source": [
        "#lambda function on list using Map\n",
        "\n",
        "n1,n2 = [3,5,7,9],[]\n",
        "n2 = list((map(lambda x : x **2, n1)))\n",
        "print(n2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9, 25, 49, 81]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cl-pl0XeqlBd",
        "colab_type": "text"
      },
      "source": [
        "**Filter Function**\n",
        "\n",
        "The Filter Function `filter()` :\n",
        "\n",
        "* Filters items out of a sequence\n",
        "* Return filtered list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2bed5vJo5un5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "693c891d-e78b-40b9-add1-6b4be02449b8"
      },
      "source": [
        "nums = range(5)\n",
        "filtering = filter(lambda x: x % 2 == 0, nums) #where this lambda function describes the condition and nums is the set of numbers ranging between 0-5\n",
        "for i in filtering:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "2\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EP2KA4pPsNmS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "93de9146-f4aa-4333-d12e-97950610e0a5"
      },
      "source": [
        "n1,n2 = [3,5,7,9], []\n",
        "n2 = list(filter(lambda x : x > 5 , n1))\n",
        "print (n2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[7, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0lhP7TNunB9",
        "colab_type": "text"
      },
      "source": [
        "**Reduce Function**\n",
        "\n",
        "The Reduce Function `reduce()` :\n",
        "\n",
        "* Applies same operation to items of a sequence\n",
        "* Uses result of operation as first parameter of next operation\n",
        "* Returns an item, not a list\n",
        "\n",
        " It returns a single value after applying a function on an iterable example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kk02Jihcxi7T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5d809bd1-fd49-42d6-9909-e02cffab91cf"
      },
      "source": [
        "from functools import reduce\n",
        "data = [4,3,2,1]\n",
        "reduce(lambda x,y: x * y, data)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKAld0st829Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#day 2 - HW\n",
        "\n",
        "         *      \n",
        "        * * \n",
        "       * * * \n",
        "      * * * * \n",
        "     * * * * * \n",
        "      * * * * \n",
        "       * * * \n",
        "        * * \n",
        "         *\n",
        "\n",
        "#make a function, get input from user, pass it as a parameter to the function, and print the dimond shape\n",
        "\n",
        "#input from the user can be anything like \"$,@,1,A\"\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}