Assignment_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Assignment_4"
      ],
      "metadata": {
        "id": "Pz36OYKscfBh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "pa4yG1ircht1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.What exactly is []?\n",
        "\n",
        "2.In a list of values stored in a variable called spam, how would you assign -  the value &#39;hello&#39; as the\n",
        "- third value? (Assume [2, 4, 6, 8, 10] are in spam.)\n",
        "- Let&#39;s pretend the spam includes the list [a', b', 'c', 'd'] for the next three queries.\n",
        "\n",
        "3.What is the value of spam[int(int('3' * 2) / 11)]?\n",
        "\n",
        "4 What is the value of spam[-1]?\n",
        "\n",
        "5.What is the value of spam[:2]?\n",
        "- Let's pretend bacon has the list [3.14, 'cat,' 11, 'cat', True] for the next  three questions.\n",
        "\n",
        "6.What is the value of bacon.index('cat')?\n",
        "\n",
        "7.How does bacon.append(99) change the look of the list value in bacon?\n",
        "\n",
        "8.How does bacon.remove('cat') change the look of the list in bacon?\n",
        "\n",
        "9.What are the list concatenation and list replication operators?\n",
        "\n",
        "10.What is difference between the list methods append() and insert()?\n",
        "\n",
        "11.What are the two methods for removing items from a list?\n",
        "\n",
        "12.Describe how list values and string values are identical.\n",
        "\n",
        "13.What's the difference between tuples and lists?\n",
        "\n",
        "14.How do you type a tuple value that only contains the integer 42?\n",
        "\n",
        "15.How do you get a list value's tuple form? How do you get a tuple value's list form?\n",
        "\n",
        "16.Variables that \"contain\" list values are not necessarily lists themselves. Instead, what do they contain?\n",
        "\n",
        "17.How do you distinguish between copy.copy() and copy.deepcopy()?\n"
      ],
      "metadata": {
        "id": "EeBJ9sGXeCxJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Answer Sheet\n"
      ],
      "metadata": {
        "id": "qqprCVD1f_HX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "uXZ-wkDPf6_Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.What exactly is []?\n",
        "\n",
        "Ans-\n",
        "\n",
        "- [ ] is a empty list, like a =[ ]\n",
        "\n",
        "- empty list value, which is a list value that contains no items. This is similar to how '' is the empty string value."
      ],
      "metadata": {
        "id": "mHr3x0fCb3iG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "YIuavyMCcFso"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.In a list of values stored in a variable called spam, how would you assign - the value 'hello' as the\n",
        "\n",
        "third value? (Assume [2, 4, 6, 8, 10] are in spam.)\n",
        "questions, let's say spam contains the list ['a', 'b', 'c', 'd'].\n",
        "\n",
        "\n",
        "Ans-\n",
        "\n",
        "spam[2] = 'hello' "
      ],
      "metadata": {
        "id": "gTeRpUM4cHru"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ans is changing the value in index 3:\n",
        "spam = [2, 4, 6, 8, 10]\n",
        "spam[2] = 'hello'\n",
        "spam"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W_1jxH96fr6y",
        "outputId": "8f3010a2-230a-4d2b-fa31-e0fb10d83ce1"
      },
      "execution_count": 183,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 'hello', 8, 10]"
            ]
          },
          "metadata": {},
          "execution_count": 183
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "dhyccFwycWZG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.What is the value of spam[int(int('3' * 2) / 11)]?\n",
        "\n",
        "Ans-\n",
        "\n",
        "'d' that '3' * 2 is the string '33', which is passed to int() before being divided by 11. This eventually evaluates to 3. Expressions can be used wherever values are used.)"
      ],
      "metadata": {
        "id": "BcewCrZvcXn-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "spam = ['a', 'b','c','d']\n",
        "spam[int(int('3' * 2) / 11)] # Thespam[int(33/11)] = spam[3]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "MtIch-xSdA9i",
        "outputId": "5b0fb97e-55f3-406b-8a52-8beff362f464"
      },
      "execution_count": 184,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'d'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 184
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "umacmCsoc4FC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4 What is the value of spam[-1]?\n",
        "\n",
        "Ans-\n",
        "\n",
        "'d'-[ Negative index for the end]"
      ],
      "metadata": {
        "id": "KiTs7g7Wc5OH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "spam = ['a', 'b','c','d']\n",
        "spam[-1] # negative is index # d"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "TxNSPTNAgYKz",
        "outputId": "64655304-360a-4151-f53e-91d4a9a1ac09"
      },
      "execution_count": 185,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'d'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 185
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "f4man1rPgflJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.What is the value of spam[:2]?\n",
        "\n",
        "- Let's pretend bacon has the list [3.14, 'cat,' 11, 'cat', True] for the next three questions.\n",
        "\n",
        "Ans-\n",
        "\n",
        "['a', 'b']"
      ],
      "metadata": {
        "id": "h5Wk_FEOgiVT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "spam[:2] # c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ccCpXIxUg602",
        "outputId": "25e470f6-d30a-4e90-d7a9-e1f671fa25d3"
      },
      "execution_count": 186,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b']"
            ]
          },
          "metadata": {},
          "execution_count": 186
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "z9H0I4rCg_cF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "6.What is the value of bacon.index('cat')?\n",
        "\n",
        "Ans-\n",
        "\n"
      ],
      "metadata": {
        "id": "rFG0DraphA8e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bacon = [3.14, 'cat', 11, 'cat', True]\n",
        "bacon.index('cat') # returns index of 1st of 'cat'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j-w3S3cvg-Fz",
        "outputId": "8cbcc743-8bfb-4e1e-8db4-d9796c7ed2e8"
      },
      "execution_count": 187,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 187
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "4uMThaVhhtPc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "7.How does bacon.append(99) change the look of the list value in bacon?\n",
        "\n",
        "Ans-\n",
        "\n",
        "[3.14, 11, 'cat', True, 99]"
      ],
      "metadata": {
        "id": "NfYo_4PVhyPy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bacon = [3.14, 'cat', 11, 'cat', True, 99]\n",
        "bacon.append(99) # append adds item the end of the list\n",
        "bacon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OdM_Eg6hhrUZ",
        "outputId": "6f8366d0-4475-4114-daa0-b1463d212285"
      },
      "execution_count": 188,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.14, 'cat', 11, 'cat', True, 99, 99]"
            ]
          },
          "metadata": {},
          "execution_count": 188
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "AfvDqOXgiI6e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "8.How does bacon.remove('cat') change the look of the list in bacon?\n",
        "\n",
        "Ans-\n",
        "\n",
        "[3.14, 11, 'cat', True] \n",
        "\n"
      ],
      "metadata": {
        "id": "A6Lhg7ZkiNt9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bacon = [3.14, 'cat', 11, 'cat', True]\n",
        "bacon.remove('cat') # remove first of item\n",
        "bacon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tVxb3bkgiBSQ",
        "outputId": "5a0439c4-5715-45c5-fdf7-6d705c8a8dfc"
      },
      "execution_count": 189,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.14, 11, 'cat', True]"
            ]
          },
          "metadata": {},
          "execution_count": 189
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "UZPBjGy-jQCM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "9.What are the list concatenation and list replication operators?\n",
        "\n",
        "Ans-\n",
        "\n",
        "( * ) is list replication operator ( + ) is list concatination operator.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "fgUVB7TwjRXs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [1,4]\n",
        "l2 = [2,5]\n",
        "# list concatination\n",
        "l1+l2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UhSOUOThjCSW",
        "outputId": "71c956b8-1deb-45b8-f43d-6e9d61b02444"
      },
      "execution_count": 190,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 4, 2, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 190
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [7,4]\n",
        "\n",
        "# list replication\n",
        "l1*3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bMhRLxC2sLNn",
        "outputId": "0fb8159f-949b-4a5e-ecb8-6c4039f4840f"
      },
      "execution_count": 191,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[7, 4, 7, 4, 7, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 191
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "RfURXqoZj04V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "10.What is difference between the list methods append() and insert()?\n",
        "\n",
        "Ans-\n",
        "\n",
        "Difference between the two methods is that:\n",
        " - append() adds an item to the end of a list, \n",
        " - whereas . insert() inserts and item in a specified position in the list."
      ],
      "metadata": {
        "id": "ZSbioOS7j6Wf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# append() adds an item to the end of a list,\n",
        "\n",
        "bacon = [3.14, 'cat', 11, 'cat', True]\n",
        "bacon.append(99) # append adds the item at the end of the list\n",
        "bacon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zv1yjjpfjle3",
        "outputId": "0d0037bc-a876-470c-ccac-05371cf1934e"
      },
      "execution_count": 192,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.14, 'cat', 11, 'cat', True, 99]"
            ]
          },
          "metadata": {},
          "execution_count": 192
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#  insert() inserts and item in a specified position in the list.\n",
        "spam = [2, 4, 6, 8, 10]\n",
        "spam.insert(2,'hello')\n",
        "spam"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yRjzXaexkg3v",
        "outputId": "80dc99b2-c485-497e-a66c-4359c52c0536"
      },
      "execution_count": 193,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 'hello', 6, 8, 10]"
            ]
          },
          "metadata": {},
          "execution_count": 193
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "Ui4gowX0krEZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "11.What are the two methods for removing items from a list?\n",
        "\n",
        "Ans-\n",
        "\n",
        "se list methods clear() , pop() , and remove() to remove items \n"
      ],
      "metadata": {
        "id": "oro-PVZck3TD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#remove(item) - removed first occurence of a item\n",
        "bacon = [3.14, 'cat', 11, 'cat', True]\n",
        "bacon.remove('cat')\n",
        "bacon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t1jTjFoKkoY2",
        "outputId": "a2cb8fcc-1ab9-4fd3-e737-4dadee34625c"
      },
      "execution_count": 194,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.14, 11, 'cat', True]"
            ]
          },
          "metadata": {},
          "execution_count": 194
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# (default last).\n",
        "bacon = [3.14, 'cat', 11, 'cat', True]\n",
        "bacon.pop()\n",
        "bacon"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QkcpgZHilFWE",
        "outputId": "07209c5a-510a-4dec-9bf7-8f110b2bbf91"
      },
      "execution_count": 195,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.14, 'cat', 11, 'cat']"
            ]
          },
          "metadata": {},
          "execution_count": 195
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "hKS3wLMsmDJR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "12.Describe how list values and string values are identical.\n",
        "\n",
        "Ans-\n",
        "\n",
        "- Both lists and strings can be passed to len()\n",
        "- Have indexes and slices\n",
        "- Can be used in for loops\n",
        "- Can be concatenated or replicated\n",
        "- Can be used with the in and not in operator"
      ],
      "metadata": {
        "id": "ld0DOpV6llXq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "EgTp803mlfZz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "13.What's the difference between tuples and lists?\n",
        "\n",
        "Ans-\n",
        "\n",
        "Lists : are mutable - they can have values added, removed, or changed. lists use the square brackets, [ and ]\n",
        "Tuples : are immutable; they cannot be changed at all. Tuples are written using parentheses, ( and )\n"
      ],
      "metadata": {
        "id": "ctbqMOR5mB6d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "Qcy86PvRmN5A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "14.How do you type a tuple value that only contains the integer 42?\n",
        "\n",
        "Ans-\n",
        "\n",
        " integer 42\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "KvwoSmqRmPrh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuple = (42,)\n",
        "tuple"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-RlN9lqhmbsH",
        "outputId": "5bc50d8d-4f94-4d08-b53f-2a99dc43c388"
      },
      "execution_count": 196,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(42,)"
            ]
          },
          "metadata": {},
          "execution_count": 196
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "KJ5v5Akfmvcq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "15.How do you get a list value's tuple form? How do you get a tuple value's list form?\n",
        "```\n",
        "Ans-\n",
        "\n",
        "- list value's tuple form:\n",
        "\n",
        "l = [1,2,3,4,5]\n",
        "l = tuple(l)\n",
        "print(l)\n",
        "\n",
        "Output - (1,2,3,4,5)\n",
        "\n",
        "- tuple value's list form:\n",
        "\n",
        "t = (1,2,3,4,5)\n",
        "t = list(t)\n",
        "print(t)\n",
        "\n",
        "Output - [1,2,3,4,5]\n",
        "```"
      ],
      "metadata": {
        "id": "OXKHVdzjm07A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "u7TZoBccnAUP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "16.Variables that \"contain\" list values are not necessarily lists themselves. Instead, what do they contain?\n",
        "\n",
        "Ans-\n",
        "\n",
        "They contain references to list values"
      ],
      "metadata": {
        "id": "12D3T0C1nBv8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "WmXyDlg4nLv0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "17.How do you distinguish between copy.copy() and copy.deepcopy()?\n",
        "\n",
        "Ans-\n",
        "\n",
        "- The copy.copy() function will do a shallow copy of a list,\n",
        "\n",
        "- The copy.deepcopy() function will do a deep copy of a list. \n",
        "only copy.deepcopy() will duplicate any lists inside the list."
      ],
      "metadata": {
        "id": "sdHZ_3KwnNp3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "R_obvCC8nZfl"
      }
    }
  ]
}