List_,_Tuple_and_Dictionary.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JebaMercy14/AI-Spartificial-Course/blob/main/List_%2C_Tuple_and_Dictionary.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z92fYkUpYCQF"
      },
      "source": [
        "# List (Continued)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nz5oWbKaZ7ud"
      },
      "source": [
        "## List unpacking\n",
        "\n",
        "Unpacking assigns elements of the list to multiple variables."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0V4kX6KaCSb",
        "outputId": "70a42ba8-11e8-42fa-818e-c26204f889b1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "purple\n",
            "cyan\n",
            "black\n"
          ]
        }
      ],
      "source": [
        "colors = ['purple', 'cyan', 'black']\n",
        "\n",
        "p, c, b = colors\n",
        "\n",
        "print(p)\n",
        "print(c)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qEUtaX8GaaBT",
        "outputId": "7dd280a0-b872-43a3-8fde-041056b0cc2f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "purple\n",
            "cyan\n",
            "['black']\n"
          ]
        }
      ],
      "source": [
        "p1, c1, *other = colors\n",
        "\n",
        "print(p1)\n",
        "print(c1)\n",
        "print(other)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rzx0Uwq5akms",
        "outputId": "fed92780-e581-4fbe-cadb-83d8cb9c8f52"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "purple\n",
            "cyan\n",
            "['black', 'blue']\n"
          ]
        }
      ],
      "source": [
        "colors.append('blue')\n",
        "\n",
        "p2, c2, *other = colors\n",
        "\n",
        "print(p1)\n",
        "print(c1)\n",
        "print(other)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7nweuFxbLId"
      },
      "source": [
        "#### Iterate over lists"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z5O2c8WIbOJD",
        "outputId": "7514de42-f139-436f-ae15-6c74f1c2557b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tulip\n",
            "rose\n",
            "sage\n",
            "lily\n",
            "iris\n",
            "daisy\n",
            "orchid\n",
            "jasmine\n",
            "poppy\n",
            "ivy\n",
            "violet\n",
            "holly\n",
            "heather\n",
            "yolanda\n"
          ]
        }
      ],
      "source": [
        "flowers = ['tulip', 'rose', 'sage', 'lily', 'iris', 'daisy', 'orchid', 'jasmine', 'poppy', 'ivy', 'violet', 'holly', 'heather', 'yolanda']\n",
        "\n",
        "for flower in flowers:\n",
        "  print(flower)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WVcVYe-Mbeac",
        "outputId": "0e59f4c4-7aca-4f91-dbc5-858c30bdd588"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 'tulip')\n",
            "(1, 'rose')\n",
            "(2, 'sage')\n",
            "(3, 'lily')\n",
            "(4, 'iris')\n",
            "(5, 'daisy')\n",
            "(6, 'orchid')\n",
            "(7, 'jasmine')\n",
            "(8, 'poppy')\n",
            "(9, 'ivy')\n",
            "(10, 'violet')\n",
            "(11, 'holly')\n",
            "(12, 'heather')\n",
            "(13, 'yolanda')\n"
          ]
        }
      ],
      "source": [
        "for item in enumerate(flowers):\n",
        "  print(item)\n",
        "\n",
        "# this returns tuples"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DjBijqNqb211",
        "outputId": "dbb8d6cf-fdb3-4764-c2a3-ab404c682156"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0: tulip\n",
            "1: rose\n",
            "2: sage\n",
            "3: lily\n",
            "4: iris\n",
            "5: daisy\n",
            "6: orchid\n",
            "7: jasmine\n",
            "8: poppy\n",
            "9: ivy\n",
            "10: violet\n",
            "11: holly\n",
            "12: heather\n",
            "13: yolanda\n"
          ]
        }
      ],
      "source": [
        "# what is we want the index and the flower separately?\n",
        "\n",
        "for idx, flower in enumerate(flowers):\n",
        "  print(f'{idx}: {flower}')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AlkYqos4cTcD"
      },
      "source": [
        "#### Index of a particular flower! or element.."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DSeMh2q5cR5M",
        "outputId": "467ba680-ee4c-4bb1-ccca-937c519ec913"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "flowers.index('ivy')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "F3Zj6nCHceUu",
        "outputId": "ab2cc175-fbcf-484a-abe8-48c064f4da1c"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-8-3500a1044909>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mflowers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'hibiscus'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: 'hibiscus' is not in list"
          ]
        }
      ],
      "source": [
        "flowers.index('hibiscus')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zkp_-rZmcrks",
        "outputId": "518b6813-29da-409c-9d35-90f5db0f2fb1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hibiscus is not found in the flowers list !\n"
          ]
        }
      ],
      "source": [
        "to_find = 'hibiscus'\n",
        "\n",
        "if to_find in flowers:\n",
        "  print(flowers.index(to_find))\n",
        "else:\n",
        "  print(f'{to_find} is not found in the flowers list !')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sh313tzZdMhP"
      },
      "source": [
        "#### Python Iterables\n",
        "\n",
        "\n",
        "In Python, an iterable is an object that includes zero, one, or many elements. \n",
        "\n",
        "An iterable has the ability to return its elements one at a time.\n",
        "\n",
        "Because of this feature, you can use a for loop to iterate over an iterable.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LacJej2Xd_cX",
        "outputId": "f9a2e2af-5102-4f9f-88eb-55d56afc17b6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n"
          ]
        }
      ],
      "source": [
        "# range function is an iterable\n",
        "\n",
        "for idx in range(3):\n",
        "    print(idx)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2zNYZTddeKr1",
        "outputId": "e71b21c0-6d2c-4c76-8c85-6e33982cd3ba"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "m\n",
            "y\n",
            "_\n",
            "f\n",
            "a\n",
            "v\n",
            "o\n",
            "r\n",
            "i\n",
            "t\n",
            "e\n",
            "_\n",
            "l\n",
            "a\n",
            "n\n",
            "g\n",
            "u\n",
            "a\n",
            "g\n",
            "e\n"
          ]
        }
      ],
      "source": [
        "# every string is an iterable\n",
        "\n",
        "my_favorite_language = 'my_favorite_language'\n",
        "\n",
        "for ch in my_favorite_language:\n",
        "  print(ch)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ycPx3hctejYJ",
        "outputId": "8166075f-565d-4518-902e-ffb13a86fd58"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tulip\n",
            "rose\n",
            "sage\n",
            "lily\n",
            "iris\n",
            "daisy\n",
            "orchid\n",
            "jasmine\n",
            "poppy\n",
            "ivy\n",
            "violet\n",
            "holly\n",
            "heather\n",
            "yolanda\n"
          ]
        }
      ],
      "source": [
        "# so are lists!\n",
        "\n",
        "for flower in flowers:\n",
        "  print(flower)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sbXr7vQseqML",
        "outputId": "a8d0bfa1-840a-41ac-ec9e-e5c7cf675a4b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tulip\n"
          ]
        }
      ],
      "source": [
        "flowers_iter = iter(flowers)\n",
        "\n",
        "next_flower = next(flowers_iter)\n",
        "print(next_flower)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3cmoJ7rCiNtD",
        "outputId": "06552788-9306-4372-8fb1-e6064600560e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rose\n"
          ]
        }
      ],
      "source": [
        "next_flower = next(flowers_iter)\n",
        "print(next_flower)\n",
        "\n",
        "# Every time, you call the next() function, it returns the next element in the iterable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "VjIHVk8kiuUT",
        "outputId": "13128ede-4c49-4505-d7ff-d095808fb3ab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "red\n",
            "green\n",
            "blue\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "StopIteration",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-b1435b3ff0a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;31m# cause an exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolors_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mStopIteration\u001b[0m: "
          ]
        }
      ],
      "source": [
        "# Once you complete looping over an iterator, the iterator becomes empty. \n",
        "# If you iterate over it again, it’ll return nothing.\n",
        "\n",
        "colors = ['red', 'green', 'blue']\n",
        "colors_iter = iter(colors)\n",
        "\n",
        "color = next(colors_iter)\n",
        "print(color)\n",
        "\n",
        "color = next(colors_iter)\n",
        "print(color)\n",
        "\n",
        "color = next(colors_iter)\n",
        "print(color)\n",
        "\n",
        "# cause an exception\n",
        "color = next(colors_iter)\n",
        "print(color)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ln6F64gHjGQ7"
      },
      "source": [
        "Since you can iterate over an iterator, the iterator is also an iterable object. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hutX_HYWjO0U",
        "outputId": "0912afdf-4541-4816-ef42-1244a0524f84"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "red\n",
            "green\n",
            "blue\n"
          ]
        }
      ],
      "source": [
        "colors = ['red', 'green', 'blue']\n",
        "iterator = iter(colors)\n",
        "\n",
        "for color in iterator:\n",
        "    print(color)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hf-D0UC6_BIz"
      },
      "source": [
        "#### Lambda, Map, Reduce, Filter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DiNSb2FTxbT4"
      },
      "source": [
        "Lambda\n",
        "\n",
        "1. Lambda expressions are used to create anonymous functions - that have no names and are called just once.\n",
        "\n",
        "2. They can have multiple arguments, but only one expression.\n",
        "\n",
        "3. Usually look like: `lambda parameters: expression`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "1zEdE267bliu"
      },
      "outputs": [],
      "source": [
        "# Use Case 1 - One-off Functions\n",
        "\n",
        "# Remember name_age : name_age[1] from yesterday?!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "gBE48K0Z-KUY"
      },
      "outputs": [],
      "source": [
        "# Use Case 2 - Functions returning functions\n",
        "\n",
        "def times(n):\n",
        "    return lambda x: x * n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hTOviVYI-R8F",
        "outputId": "7a6d60d7-eee1-416e-8aaf-a8976159dedf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<function times.<locals>.<lambda> at 0x7f5b8c0c19d0>\n"
          ]
        }
      ],
      "source": [
        "doubler = times(2)\n",
        "print(doubler)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jdx9sQz8-YmF",
        "outputId": "542a2660-b9ea-490c-bb6b-578bbb8036fc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "two_times_3 = doubler(3)\n",
        "print(two_times_3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xgp1O180-kEW",
        "outputId": "d58e93ec-dda8-4e89-e1d8-7d2003283ad9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ],
      "source": [
        "tripler = times(3)\n",
        "three_times_4 = tripler(4)\n",
        "print(three_times_4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHtiAz4O9_f1"
      },
      "source": [
        "Map - transformation of an entire list.\n",
        "\n",
        "It calls a function on every item of a list and returns an iterator."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z6s24INw_As3",
        "outputId": "47906883-fcc1-4ff5-923f-599e9c487819"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[160, 182, 156, 200, 174]\n"
          ]
        }
      ],
      "source": [
        "my_marks = [80, 91, 78, 100, 87]\n",
        "\n",
        "my_new_marks = []\n",
        "\n",
        "for mark in my_marks:\n",
        "    my_new_marks.append(mark*2)\n",
        "\n",
        "print(my_new_marks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oemw-H8k_eu0",
        "outputId": "4d48156e-2981-44ab-aff9-106a109a8723"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[160, 182, 156, 200, 174]\n"
          ]
        }
      ],
      "source": [
        "my_new_marks_1 = map(lambda mark: mark*2, my_marks)\n",
        "print(list(my_new_marks_1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V-rTHxpYAkMQ",
        "outputId": "7c2ec30f-24ca-4234-fe11-b81f12e49b00"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['FINISH COLLEGE', 'PAY RENT', 'STUDY FOR EXAM']\n"
          ]
        }
      ],
      "source": [
        "# applying map to strings\n",
        "\n",
        "problems = ['finish College', 'Pay rent', 'study for EXAM']\n",
        "\n",
        "big_problems = map(lambda problem:problem.upper(), problems)\n",
        "print(list(big_problems))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-8p62HVABAEY",
        "outputId": "f3a9e5bf-cfa0-4e1f-cce7-a4c707a9eaf2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['finish college', 'pay rent', 'study for exam']\n"
          ]
        }
      ],
      "source": [
        "small_problems = map(lambda problem:problem.lower(), problems)\n",
        "print(list(small_problems))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lzHnJvgLDKDq",
        "outputId": "8cfb6743-90f0-4146-b1d8-00e6e6d42738"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['Samsung', 400, 40.0], ['Toshiba', 450, 45.0], ['Lenovo', 700, 70.0]]\n"
          ]
        }
      ],
      "source": [
        "# applying map to tuples\n",
        "\n",
        "costs = [['Samsung', 400],\n",
        "         ['Toshiba', 450],\n",
        "         ['Lenovo', 700]]\n",
        "\n",
        "tax = 0.1\n",
        "\n",
        "costs = map(lambda item: [item[0], item[1], item[1] * tax], costs)\n",
        "\n",
        "print(list(costs))\n",
        "\n",
        "# costs = list(map(lambda item: [item[0], item[1], item[1] * tax], costs))\n",
        "# print(costs)\n",
        "# costs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FbOwZ3AHGBoS"
      },
      "source": [
        "The filter() function iterates over the elements of the list and applies the fn() function to each element. \n",
        "\n",
        "It returns an iterator for the elements where the fn() returns True.\n",
        "\n",
        "```\n",
        "filter(fn, list)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cxg70I20EIJg",
        "outputId": "c51e1e33-43ea-4a4c-d683-ff77998526b2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[80, 78, 87]\n"
          ]
        }
      ],
      "source": [
        "my_marks = [80, 51, 78, 60, 87]\n",
        "\n",
        "good_marks = []\n",
        "\n",
        "for mark in my_marks:\n",
        "  if mark > 60:\n",
        "    good_marks.append(mark)\n",
        "\n",
        "print(good_marks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Tez7GpCEfzv",
        "outputId": "2924495d-ba7e-4e03-b38c-6060a755690e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[80, 78, 87]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ],
      "source": [
        "good_marks_1 = list(filter(lambda mark: mark > 60, my_marks))\n",
        "\n",
        "good_marks_1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XG0VcD12GZwB",
        "outputId": "0ecccb37-c06d-4d75-be37-b0c832081171"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['China', 1394015977], ['United States', 329877505], ['India', 1326093247]]\n"
          ]
        }
      ],
      "source": [
        "# filter on lists\n",
        "\n",
        "countries = [\n",
        "    ['China', 1394015977],\n",
        "    ['United States', 329877505],\n",
        "    ['India', 1326093247],\n",
        "    ['Indonesia', 267026366],\n",
        "    ['Bangladesh', 162650853],\n",
        "    ['Pakistan', 233500636],\n",
        "    ['Nigeria', 214028302],\n",
        "    ['Brazil', 21171597],\n",
        "    ['Russia', 141722205],\n",
        "    ['Mexico', 128649565]\n",
        "]\n",
        "\n",
        "\n",
        "populated = filter(lambda c: c[1] > 300000000, countries)\n",
        "\n",
        "print(list(populated))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBlnEn1NGwii"
      },
      "source": [
        "Reduce - to reduce a list of elements to one element."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y3G-vlwAG2cY",
        "outputId": "82da6915-8b59-4840-dda5-4dfa04bfe8ea"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "356\n"
          ]
        }
      ],
      "source": [
        "my_marks = [80, 51, 78, 60, 87]\n",
        "\n",
        "total = 0\n",
        "\n",
        "for mark in my_marks:\n",
        "    total += mark\n",
        "\n",
        "print(total)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "grQ30t0aH3lm",
        "outputId": "3194d20d-77f6-42fe-cd6b-6c86f55e993e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a = 80, b = 51, 80 + 51 = 131\n",
            "a = 131, b = 78, 131 + 78 = 209\n",
            "a = 209, b = 60, 209 + 60 = 269\n",
            "a = 269, b = 87, 269 + 87 = 356\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "356"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ],
      "source": [
        "# Unlike the map() and filter() functions, the reduce() isn’t a built-in function in Python. \n",
        "# It belongs to the functools module.\n",
        "from functools import reduce\n",
        "\n",
        "def sum(a, b):\n",
        "  print(f\"a = {a}, b = {b}, {a} + {b} = {a+b}\")\n",
        "  return a + b\n",
        "\n",
        "total = reduce(sum, my_marks)\n",
        "total"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQTM6BTjI94v"
      },
      "source": [
        "The reduce() function cumulatively adds two elements of the list from left to right and reduces the whole list into a single value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OY4p1AOWG3Ct",
        "outputId": "a056f820-7ab7-4cfd-8876-fed9d4b0a4cf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "356\n"
          ]
        }
      ],
      "source": [
        "# we can define the sum function by a lambda exp\n",
        "\n",
        "total = reduce(lambda a, b: a + b, my_marks)\n",
        "\n",
        "print(total)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKZLhtZlKn8b"
      },
      "source": [
        "#### List Comprehensions\n",
        "\n",
        "Use list comprehensions instead of map() or filter() to make your code more concise and readable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2xVyoKAVKrFC",
        "outputId": "4d773a46-84c9-4817-f8a8-4351a981ae27"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[6400, 4900, 10000, 4489, 7921]\n",
            "[6400, 4900, 10000, 4489, 7921]\n"
          ]
        }
      ],
      "source": [
        "my_marks = [80, 70, 100, 67, 89]\n",
        "\n",
        "my_marks_squared = list(map(lambda mark:mark**2, my_marks))\n",
        "print(my_marks_squared)\n",
        "\n",
        "my_marks_squared_1 = [mark**2 for mark in my_marks]\n",
        "print(my_marks_squared_1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NaU5Lsl3LRr7",
        "outputId": "4a67ee3f-5f63-4406-e1ab-c94cb985e339"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['K2', 8611], ['Everest', 8848]]\n"
          ]
        }
      ],
      "source": [
        "mountains = [\n",
        "    ['Makalu', 8485],\n",
        "    ['Lhotse', 8516],\n",
        "    ['Kanchendzonga', 8586],\n",
        "    ['K2', 8611],\n",
        "    ['Everest', 8848]\n",
        "]\n",
        "\n",
        "\n",
        "highest_mountains = list(filter(lambda m: m[1] > 8600, mountains))\n",
        "\n",
        "print(highest_mountains)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2tycv38aLUMk",
        "outputId": "7c193cce-beea-4f99-faa4-29124e464963"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['K2', 8611], ['Everest', 8848]]\n"
          ]
        }
      ],
      "source": [
        "highest_mountains_1 = [m for m in mountains if m[1] > 8600]\n",
        "print(highest_mountains_1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_UKkboSPpdU6"
      },
      "source": [
        "### Dictionary Data Structure"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "x4Q4081tpkGZ"
      },
      "outputs": [],
      "source": [
        "empty_dict = {}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "6-sT3RawqYbk"
      },
      "outputs": [],
      "source": [
        "planet_info = {\n",
        "    'name' : 'Jupiter',\n",
        "    'number_of_moons' : 79,\n",
        "    'number_in_solar_system' : 'fifth',\n",
        "    'life_support' : 'some moons have oceans with water',\n",
        "    'others' : 'gas_giant, biggest_planet, eternal_storms'\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F5d32zTOrzmx",
        "outputId": "5a7fd94e-84f6-4fd6-b4b3-11b89f5c675d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "79"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ],
      "source": [
        "planet_info['number_of_moons']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F1LHu-0sr3_K",
        "outputId": "9d44ef47-acbb-418e-df2e-0f4a8922559a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name': 'Jupiter',\n",
              " 'number_of_moons': 79,\n",
              " 'number_in_solar_system': 'fifth',\n",
              " 'life_support': 'some moons have oceans with water',\n",
              " 'others': 'gas_giant, biggest_planet, eternal_storms'}"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ],
      "source": [
        "planet_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "f6ZdrmRyrpKY"
      },
      "outputs": [],
      "source": [
        "# we can change values \n",
        "\n",
        "planet_info['life_support'] = 'Nothing concrete we know of so far'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l_nw7I05sA4b",
        "outputId": "a3bc2430-6287-4a7c-b161-efa800e0dfe4"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name': 'Jupiter',\n",
              " 'number_of_moons': 79,\n",
              " 'number_in_solar_system': 'fifth',\n",
              " 'life_support': 'Nothing concrete we know of so far',\n",
              " 'others': 'gas_giant, biggest_planet, eternal_storms'}"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ],
      "source": [
        "planet_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dyMIIsNysFd7",
        "outputId": "aab8eb5a-708f-43aa-8591-3eb754052016"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name': 'Jupiter',\n",
              " 'number_of_moons': 79,\n",
              " 'number_in_solar_system': 'fifth',\n",
              " 'life_support': 'Nothing concrete we know of so far',\n",
              " 'others': 'gas_giant, biggest_planet, eternal_storms',\n",
              " 'planet_name': 'Jupiter'}"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ],
      "source": [
        "# we cannot change keys\n",
        "\n",
        "planet_info['planet_name'] = 'Jupiter'\n",
        "planet_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "YqfeB-M7sQS-"
      },
      "outputs": [],
      "source": [
        "del planet_info['planet_name']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XI-MJk5ZwAko",
        "outputId": "ade94676-f44f-47e1-d238-c714c988c96f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name': 'Jupiter',\n",
              " 'number_of_moons': 79,\n",
              " 'number_in_solar_system': 'fifth',\n",
              " 'life_support': 'Nothing concrete we know of so far',\n",
              " 'others': 'gas_giant, biggest_planet, eternal_storms'}"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ],
      "source": [
        "planet_info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K41cGoHqwLAZ",
        "outputId": "964f37e3-7f80-404a-f69f-0e8485dad0d9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "79"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ],
      "source": [
        "moons = planet_info.get('number_of_moons')\n",
        "moons"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "LxpevpudxjYG",
        "outputId": "99f7583b-1866-4750-c246-ac52f594bfc7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'0-00-000'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 46
        }
      ],
      "source": [
        "# It returns the '0-00-000' string if the ssn key doesn’t exist in the dictionary:\n",
        "\n",
        "storms = planet_info.get('storms', '0-00-000')\n",
        "storms"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "985Cqf0qzis4",
        "outputId": "76537e1a-555e-4abc-ef26-aec5af183da7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name: Jupiter\n",
            "number_of_moons: 79\n",
            "number_in_solar_system: fifth\n",
            "life_support: Nothing concrete we know of so far\n",
            "others: gas_giant, biggest_planet, eternal_storms\n"
          ]
        }
      ],
      "source": [
        "# looping through a dictionary\n",
        "\n",
        "for key, value in planet_info.items():\n",
        "    print(f\"{key}: {value}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XwmOnWW-0p_p",
        "outputId": "ca04d1d9-c720-49e5-a618-4a40b0f5849e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name\n",
            "number_of_moons\n",
            "number_in_solar_system\n",
            "life_support\n",
            "others\n"
          ]
        }
      ],
      "source": [
        "for key in planet_info.keys():\n",
        "    print(key)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxHA9CRl09J5",
        "outputId": "1b15581d-1635-4283-bf1e-7e649544e6de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name\n",
            "number_of_moons\n",
            "number_in_solar_system\n",
            "life_support\n",
            "others\n"
          ]
        }
      ],
      "source": [
        "for key in planet_info:\n",
        "  print(key)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LHaN0VyU1P9F",
        "outputId": "87a49de1-bf0b-43f1-80a2-edfb4d341f6e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jupiter\n",
            "79\n",
            "fifth\n",
            "Nothing concrete we know of so far\n",
            "gas_giant, biggest_planet, eternal_storms\n"
          ]
        }
      ],
      "source": [
        "for value in planet_info.values():\n",
        "    print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X_BEP38V29Ra"
      },
      "source": [
        "#### Dictionary Comprehension"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "jvVQqyS22GuE"
      },
      "outputs": [],
      "source": [
        "stocks = {\n",
        "    'AAPL': 121,\n",
        "    'AMZN': 3380,\n",
        "    'MSFT': 219,\n",
        "    'BIIB': 280,\n",
        "    'QDEL': 266,\n",
        "    'LVGO': 144\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "llnBULte3Ht3",
        "outputId": "be825596-e1ac-4906-f6d3-3f082cbc330a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'AAPL': 123.42, 'AMZN': 3447.6, 'MSFT': 223.38, 'BIIB': 285.6, 'QDEL': 271.32, 'LVGO': 146.88}\n"
          ]
        }
      ],
      "source": [
        "new_stocks = {}\n",
        "for symbol, price in stocks.items():\n",
        "    new_stocks[symbol] = price*1.02\n",
        "\n",
        "print(new_stocks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r8zdTqbv3cXX",
        "outputId": "e5432e78-13f4-48d2-a96f-45d4dc24e28a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'AAPL': 123.42, 'AMZN': 3447.6, 'MSFT': 223.38, 'BIIB': 285.6, 'QDEL': 271.32, 'LVGO': 146.88}\n"
          ]
        }
      ],
      "source": [
        "new_stocks_1 = {symbol: price * 1.02 for (symbol, price) in stocks.items()}\n",
        "\n",
        "print(new_stocks_1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-UAsNSWz3yWe",
        "outputId": "61e61c12-55aa-4eed-aeaa-b8a22b666aed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'AMZN': 3380, 'MSFT': 219, 'BIIB': 280, 'QDEL': 266}\n"
          ]
        }
      ],
      "source": [
        "selected_stocks = {}\n",
        "for symbol, price in stocks.items():\n",
        "    if price > 200:\n",
        "        selected_stocks[symbol] = price\n",
        "\n",
        "print(selected_stocks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KtoJcUnN33R-",
        "outputId": "2a0b0963-1460-4587-890a-08579faef8ef"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'AMZN': 3380, 'MSFT': 219, 'BIIB': 280, 'QDEL': 266}\n"
          ]
        }
      ],
      "source": [
        "#A dictionary comprehension iterates over items of a dictionary \n",
        "# and allows you to create a new dictionary by transforming or filtering each item.\n",
        "\n",
        "selected_stocks_1 = {s: p for (s, p) in stocks.items() if p > 200}\n",
        "\n",
        "print(selected_stocks_1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-kW969Yn5ONE"
      },
      "source": [
        "### Unpacking Tuples"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d03S29LG5SVN",
        "outputId": "6c75b8d6-2398-49c6-98f1-da19d201d208"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n",
            "()\n"
          ]
        }
      ],
      "source": [
        "a = tuple()\n",
        "print(type(a))\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UWAn5Rnx5fDO",
        "outputId": "163a0961-a153-4fc0-ee01-0855a86e5374"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1,)\n"
          ]
        }
      ],
      "source": [
        "b = (1,)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WnwCrtYk5jJZ",
        "outputId": "f31219d8-a817-4bef-dddc-b71a3512a878"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n"
          ]
        }
      ],
      "source": [
        "c = (1)\n",
        "print(type(c))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MtFIBXwA5pKG",
        "outputId": "9e30fa1f-12d0-4271-b1d5-1e5429c9527c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "-1\n",
            "2\n",
            "0.5\n",
            "0\n"
          ]
        }
      ],
      "source": [
        "x, y = (1, 2)\n",
        "print(x + y)\n",
        "print(x - y)\n",
        "print(x * y)\n",
        "print(x / y)\n",
        "print(x // y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJEPVLgr6dN0",
        "outputId": "829e794b-2b6c-4526-ea82-5bfce96138f1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "60\n"
          ]
        }
      ],
      "source": [
        "x, y, z = 10, 20, 30\n",
        "\n",
        "print(x + y +z)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "3XohThKS6hYq",
        "outputId": "a2d3b451-f1c6-4246-f2fd-21cf31410938"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-61-275e7e2ee983>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m30\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 2)"
          ]
        }
      ],
      "source": [
        "x, y = 10, 20, 30"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vMFdsm0c6uav",
        "outputId": "9ba6d39f-7370-4199-e7e2-30a0fa4489ba"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ],
      "source": [
        "x, y, _ = 10, 20, 30\n",
        "print(_)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TbKOguoM7PUy"
      },
      "source": [
        "Extended unpacking using the * operator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JZSmR_D8624N",
        "outputId": "be4d27c7-ef0e-422a-e2a3-0458fbe8ad3a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 0.5]\n",
            "192\n",
            "210\n"
          ]
        }
      ],
      "source": [
        "r, g, *other = (192, 210, 100, 0.5)\n",
        "print(other)\n",
        "print(r)\n",
        "print(g)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "id": "qjX7F_cX7KOW",
        "outputId": "d36e8795-30e9-4523-c893-0f29c0193d7a"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-64-791c377882a9>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    x, y, *z, *t = (10, 20, 30, '10:30')\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m two starred expressions in assignment\n"
          ]
        }
      ],
      "source": [
        "x, y, *z, *t = (10, 20, 30, '10:30')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hgMTqpYF7loF"
      },
      "source": [
        "Using the * operator on the right hand side"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T4bBHfwD7Y0j",
        "outputId": "255ff876-68a6-4a38-9fe6-22818419a536"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 3, 5, 2, 4, 6)\n"
          ]
        }
      ],
      "source": [
        "odd_numbers = (1, 3, 5)\n",
        "even_numbers = (2, 4, 6)\n",
        "\n",
        "# The following example uses the * operator to unpack those tuples and merge them into a single tuple:\n",
        "\n",
        "numbers = (*odd_numbers, *even_numbers)\n",
        "print(numbers)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Hr7rdUE8PYN"
      },
      "source": [
        "#### *args"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tup = (1, 2, 3, 4, 5)\n",
        "tup1 = tuple(map(lambda x: x/2, tup))\n",
        "# Print the output of tup1\n",
        "print(\"(0.5, 1.0, 1.5, 2.0, 2.5)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6k8HAfzUDuep",
        "outputId": "efa8d415-4064-4d43-ae05-50fb2102d215"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0.5, 1.0, 1.5, 2.0, 2.5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "1KsWn-CBphoG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5731a90a-7138-44eb-bdc4-2b9f8c437247"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saturn\n",
            "Key does not exist for the provided value!\n"
          ]
        }
      ],
      "source": [
        "def func(val, dict):\n",
        "  for key, value in dict.items():\n",
        "    if val == value:\n",
        "      return key\n",
        "  return \"Key does not exist for the provided value!\"\n",
        "\n",
        "moon_data = {\n",
        "    \"Mercury\" : 0,\n",
        "    \"Venus\" : 0,\n",
        "    \"Earth\" : 1, \n",
        "    \"Mars\" : 2,\n",
        "    \"Jupiter\" : 79,\n",
        "    \"Saturn\" : 82, \n",
        "    \"Uranus\" : 27,\n",
        "    \"Neptune\" : 14,\n",
        "}\n",
        "\n",
        "print(func(max(moon_data.values()), moon_data))      # Line 1\n",
        "print(func(max(moon_data.values()) + 1, moon_data))  # Line 2"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "phy_concepts = [\"Gravitational Lensing\", \"\", \"Black Holes\", \"Quantum Entanglment\", \"\", \"Photoelectric Effect\", \"\", \"Gravitational Waves\"]\n",
        "\n",
        "# Given List\n",
        "phy_concepts = [\"Gravitational Lensing\", \"\", \"Black Holes\", \"Quantum Entanglment\", \"\", \"Photoelectric Effect\", \"\", \"Gravitational Waves\"]\n",
        "\n",
        "# Code for removing the empty strings \n",
        "phy_concepts = list(filter(None, phy_concepts))\n",
        "\n",
        "# Print the output\n",
        "print(phy_concepts)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R0h8kLxLEKNX",
        "outputId": "9958258e-0e22-403f-d9fc-95b8ca8b1f28"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Gravitational Lensing', 'Black Holes', 'Quantum Entanglment', 'Photoelectric Effect', 'Gravitational Waves']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6zDKRKZ48tie",
        "outputId": "7b8a67b4-8c14-4a00-e742-a484fb28b9e7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original List:-  [1, 2, [3, 4, 5, [6], 7, 8, 9], 10, 12]\n",
            "Altered List:-   [1, 2, [3, 4, 5, [6], 5, 4, 3], 2, 1]\n"
          ]
        }
      ],
      "source": [
        "\n",
        "lst = [1, 2, [3, 4, 5, [6], 7, 8, 9], 10, 12]\n",
        "\n",
        "print(f\"Original List:-  {lst}\")\n",
        "\n",
        "for i in list(range(2, 5)):\n",
        "\n",
        "  if i == 2:\n",
        "    for j in list(range(-3, 0)):\n",
        "      lst[i][j] = lst[i][-j-1]\n",
        "  \n",
        "  else:\n",
        "    lst[i] = lst[-i-1]\n",
        "\n",
        "print(f\"Altered List:-   {lst}\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Lk5qyFpdEX37"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}