2nd_feb_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8d490a6b-b439-4649-8acc-d860c6f9be96",
   "metadata": {},
   "source": [
    "# Answer 1\n",
    "\n",
    "A tuple is a collection of ordered and immutable elements, which means that once a tuple is created, its elements cannot be modified. Tuples are similar to lists in that they can contain elements of different data types, but they are distinguished by their immutability.\n",
    "\n",
    "The following are some characteristics of tuples:\n",
    "\n",
    "Tuples are enclosed in parentheses ( ) and elements are separated by commas.\n",
    "Tuples can have any number of elements.\n",
    "Tuples can contain elements of different data types, including numbers, strings, booleans, and other tuples.\n",
    "Tuples are indexed, which means that each element can be accessed using its position or index, starting from 0.\n",
    "Tuples can be sliced, which means that a subset of the elements can be selected by specifying a range of indices.\n",
    "Tuples can be used as keys in dictionaries because they are immutable.\n",
    "In summary, tuples are immutable and have several characteristics that make them useful for certain programming tasks, such as when a collection of elements needs to be fixed and unchangeable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbeafb85-f2b0-4699-8374-c8682f8c8334",
   "metadata": {},
   "source": [
    "# Answer 2\n",
    "\n",
    "The two tuple methods in Python are count() and index(). Here are examples of each method:\n",
    "\n",
    "count(): This method returns the number of times a specified element appears in the tuple. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "13e290b8-2e53-4a91-b626-c7ba37742b07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 4, 4)\n",
    "count_of_fours = my_tuple.count(4)\n",
    "print(count_of_fours) # Output: 3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a50ac2-6b1f-4c93-9466-f6ca09f6b544",
   "metadata": {},
   "source": [
    "index(): This method returns the index of the first occurrence of a specified element in the tuple. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "29811517-a354-4e31-8fd3-51769afc10c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 4, 4)\n",
    "index_of_two = my_tuple.index(2)\n",
    "print(index_of_two) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56d5a523-1a0a-4bff-bf6e-e0219e5088d7",
   "metadata": {},
   "source": [
    "As for why tuples have only two in-built methods as compared to lists, the primary reason is that tuples are designed to be immutable, meaning that they cannot be modified once they are created. As a result, many of the methods that are available for lists, such as append(), insert(), and pop(), which modify the list in place, are not applicable to tuples. Instead, the two methods that are available for tuples, count() and index(), are focused on accessing and analyzing the elements of the tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e9c0e82-e38f-46b4-82f0-25dff50b589e",
   "metadata": {},
   "source": [
    "# Answer 3\n",
    "In Python, sets are the collection datatypes that do not allow duplicate items. A set is an unordered collection of unique elements, and it is defined using curly braces { } or the set() constructor.\n",
    "\n",
    "Here is an example code using a set to remove duplicates from the given list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e306a724-6981-4b4b-b596-586d0f85e92f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 1, 1, 2, 1, 3, 1, 4, 2, 1, 2, 2, 2, 3, 2, 4, 3, 1, 3, 2, 3, 3, 3, 4, 4, 1, 4, 2, 4, 3, 4, 4]\n",
    "unique_set = set(my_list)\n",
    "new_list = list(unique_set)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5cc3c66-b7e0-45ba-b362-be6a63895f5d",
   "metadata": {},
   "source": [
    "In the above code, we first create a list my_list with duplicate items. Then we use the set() constructor to convert the list to a set, which automatically removes duplicates. Finally, we convert the set back to a list using the list() constructor and store the result in new_list. The output shows that the duplicates have been removed and we are left with a list of unique elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a73be627-2d39-4053-8b70-8f2fb888d9d7",
   "metadata": {},
   "source": [
    "# Answer 4\n",
    "\n",
    "In Python, both union() and update() methods are used to combine two or more sets into a single set, but they work in slightly different ways.\n",
    "\n",
    "The union() method creates a new set that contains all the unique elements from the original sets, without modifying the original sets. The union() method can be called using the | operator or by calling the method directly on a set.\n",
    "\n",
    "Here is an example of using the union() method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "77c1220d-cb2b-44ef-a98a-9cfb832da5e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "union_set = set1.union(set2)\n",
    "print(union_set) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50986feb-d429-4a8d-96d3-03d2a4977193",
   "metadata": {},
   "source": [
    "In the above example, set1 contains elements {1, 2, 3} and set2 contains elements {3, 4, 5}. The union() method is used to create a new set union_set that contains all unique elements from both sets. The output shows that the resulting set {1, 2, 3, 4, 5} contains all unique elements from both sets.\n",
    "\n",
    "On the other hand, the update() method modifies the original set by adding all the elements from one or more sets to it. The update() method can be called using the |= operator or by calling the method directly on a set.\n",
    "\n",
    "Here is an example of using the update() method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3a970c00-7659-4f3d-a39a-7a1ca56da483",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set1.update(set2)\n",
    "print(set1) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21e08380-ffa4-4ce5-a76c-f1f866d6b2c9",
   "metadata": {},
   "source": [
    "In the above example, set1 contains elements {1, 2, 3} and set2 contains elements {3, 4, 5}. The update() method is used to modify set1 by adding all the unique elements from set2 to it. The output shows that set1 now contains all unique elements from both sets {1, 2, 3, 4, 5}.\n",
    "In summary, the main difference between the union() and update() methods is that union() creates a new set without modifying the original sets, while update() modifies the original set by adding all unique elements from one or more sets to it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6aa5d3d-84a5-489e-9e50-fbf64857a5e8",
   "metadata": {},
   "source": [
    "# Answer 5\n",
    "\n",
    "In Python, a dictionary is a collection of key-value pairs that allows you to store and retrieve data in an associative manner. Dictionaries are defined using curly braces { } and each key-value pair is separated by a colon :. The keys must be unique, immutable objects such as strings, numbers, or tuples, while the values can be of any data type.\n",
    "\n",
    "Here is an example of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "41b6dbbd-c927-477f-9349-431d93cf160b",
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\n",
    "  \"name\": \"Ahmad\",\n",
    "  \"age\": 23,\n",
    "  \"gender\": \"Male\",\n",
    "  \"occupation\": \"Engineer\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c73bbfea-bf80-4ea8-b28a-56a1bb10a4be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Ahmad', 'age': 23, 'gender': 'Male', 'occupation': 'Engineer'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d306c3-f702-4487-9d19-873202b6ac58",
   "metadata": {},
   "source": [
    "In this example, we have a dictionary person with keys \"name\", \"age\", \"gender\", and \"occupation\", and their corresponding values \"John\", 30, \"Male\", and \"Engineer\" respectively. We can access the values of the dictionary using the keys, like person[\"name\"] would return \"John\".\n",
    "Dictionaries are unordered in Python, which means that the elements are not stored in a specific order. The order of elements is arbitrary and can change whenever the dictionary is modified. In other words, you cannot assume that the order of elements in the dictionary will remain the same across different operations. If you need a dictionary that maintains the order of its elements, you can use the OrderedDict class from the collections module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74d661c1-fc48-4433-9de9-eef1378c9c38",
   "metadata": {},
   "source": [
    "# Answer 6\n",
    "\n",
    "Yes, we can create a nested dictionary in Python. A nested dictionary is a dictionary that contains one or more dictionaries as values. These dictionaries can be accessed using their respective keys.\n",
    "\n",
    "Here is an example of a simple one-level nested dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7d6c7367-95cc-427b-877f-318dee77467d",
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\n",
    "  \"name\": \"Ahmad\",\n",
    "  \"age\": 23,\n",
    "  \"address\": {\n",
    "    \"street\": \"Barood khana\",\n",
    "    \"city\": \"Lucknow\",\n",
    "    \"state\": \"UP\",\n",
    "    \"zipcode\": \"226018\"\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "503406df-c1d2-411b-a63c-d1fb2afd6565",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Ahmad',\n",
       " 'age': 23,\n",
       " 'address': {'street': 'Barood khana',\n",
       "  'city': 'Lucknow',\n",
       "  'state': 'UP',\n",
       "  'zipcode': '226018'}}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6d472d-504e-4c58-bb12-e2cc44e37233",
   "metadata": {},
   "source": [
    "We can access the nested dictionary values using the same square bracket notation as before, but we need to specify the key for the outer dictionary, and then the key for the inner dictionary, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c008d682-6c5e-4bb7-8ace-ae0c2db5fb50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lucknow\n"
     ]
    }
   ],
   "source": [
    "print(person[\"address\"][\"city\"]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a878feb4-b9d7-44c3-b611-c2556cdf1b3b",
   "metadata": {},
   "source": [
    "# Answer 7\n",
    "\n",
    "To create a new key \"topics\" in the given dictionary dict1 and add the list ['Python', 'Machine Learning', 'Deep Learning'] as its value using the setdefault() method, we can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ccdf2ceb-dbf2-460d-9599-7d133d8799fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'language': 'Python', 'course': 'Data Science Masters', 'topics': ['Python', 'Machine Learning', 'Deep Learning']}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'language': 'Python', 'course': 'Data Science Masters'}\n",
    "\n",
    "# Add a new key 'topics' with value ['Python', 'Machine Learning', 'Deep Learning']\n",
    "dict1.setdefault('topics', ['Python', 'Machine Learning', 'Deep Learning'])\n",
    "\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0af639b-6852-4b0c-92c1-7f446456a004",
   "metadata": {},
   "source": [
    "Here, we use the setdefault() method to set the value of the key \"topics\" to ['Python', 'Machine Learning', 'Deep Learning']. If the key \"topics\" does not already exist in the dictionary, then setdefault() creates the key with the specified value. If the key \"topics\" already exists, then setdefault() does nothing and returns the existing value.\n",
    "In this example, the key \"topics\" did not exist in the dictionary, so setdefault() created the key with the value ['Python', 'Machine Learning', 'Deep Learning']. The resulting dictionary contains the new key and its value, along with the existing keys \"language\" and \"course\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "782efbfd-6169-481b-abb5-daa3e91e18bc",
   "metadata": {},
   "source": [
    "# Answer 8\n",
    "\n",
    "The three view objects in Python dictionaries are:\n",
    "\n",
    "dict_keys: It is a view object that contains the keys of a dictionary.\n",
    "dict_values: It is a view object that contains the values of a dictionary.\n",
    "dict_items: It is a view object that contains the key-value pairs of a dictionary as tuples.\n",
    "To display these view objects for the given dictionary dict1 = {'Sport': 'Cricket', 'Teams': ['India', 'Australia', 'England', 'South Africa', 'Sri Lanka', 'New Zealand']}, we can use the following built-in methods in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "23303119-cb0b-4a64-b422-96e40287045a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys view: dict_keys(['Sport', 'Teams'])\n",
      "Values view: dict_values(['Cricket', ['India', 'Australia', 'England', 'South Africa', 'Sri Lanka', 'New Zealand']])\n",
      "Items view: dict_items([('Sport', 'Cricket'), ('Teams', ['India', 'Australia', 'England', 'South Africa', 'Sri Lanka', 'New Zealand'])])\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Sport': 'Cricket', 'Teams': ['India', 'Australia', 'England', 'South Africa', 'Sri Lanka', 'New Zealand']}\n",
    "\n",
    "# Create view objects\n",
    "keys_view = dict1.keys()\n",
    "values_view = dict1.values()\n",
    "items_view = dict1.items()\n",
    "\n",
    "# Display view objects\n",
    "print('Keys view:', keys_view)\n",
    "print('Values view:', values_view)\n",
    "print('Items view:', items_view)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6730529c-aa55-4ceb-a199-5b1bd56151c8",
   "metadata": {},
   "source": [
    "Here, we first create the view objects keys_view, values_view, and items_view using the keys(), values(), and items() methods of the dictionary dict1, respectively.\n",
    "We then display these view objects using the print() function. The keys_view and values_view objects are displayed using their default dict_keys and dict_values format. The items_view object is displayed as a list of tuples, where each tuple contains a key-value pair from the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64da9068-56fa-41a2-a4f9-88d5df54ebfb",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}