Data Structures .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In computer science, a data structure is a data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.\n",
    "\n",
    "There are basically four type of data structure in Python i.e. ***List, Tuple, Dictionary and Set***.\n",
    "\n",
    "We will go through these one by one. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is a data structure that holds an ordered collection of items i.e. you can store a sequence of items in a list. \n",
    "\n",
    "List can be written as a list of comma-separated values (items) between square brackets.\n",
    "\n",
    "Important thing about a list is that items in a list need not be of the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruitlist = ['apple', 'mango', 'carrot', 'banana'] #creating list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'mango', 'carrot', 'banana']\n"
     ]
    }
   ],
   "source": [
    "print(fruitlist) #printing List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "Subject_and_year_list = ['physics', 'chemistry', 1997, 2000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 1997, 2000]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subject_and_year_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Values in Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For selecting any value we use the square brackets for slicing along with the index or indices to obtain value available at that index\n",
    "\n",
    "#### Selecting only 1 value \n",
    "\n",
    "list_name \\[ index ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fruitlist[0]:  apple\n"
     ]
    }
   ],
   "source": [
    "print(\"fruitlist[0]: \", fruitlist[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Selecting multiple value \n",
    "\n",
    "list_name \\[ Start_index : End_index-1 ]\n",
    "\n",
    "i.e. from index 1 to 3, it starts from index 1 and end at last range-1  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subject_and_year_list[1:5]:  ['chemistry', 1997]\n"
     ]
    }
   ],
   "source": [
    "print(\"Subject_and_year_list[1:5]: \", Subject_and_year_list[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can update single or multiple values in list \n",
    "\n",
    "#### Updating single value \n",
    "\n",
    "listname \\[ index ] = new value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 1997, 2000]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subject_and_year_list #given list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "Subject_and_year_list[2] = \"maths\" #chnaging 2nd index of list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 'maths', 2000]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subject_and_year_list #after update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Updating Multiple values in list \n",
    "\n",
    "list_name \\[ Start_index : End_index-1 ] = new list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'mango', 'carrot', 'banana']"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruitlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruitlist[1:3] = [\"carrot\",\"mango\"] #changing index 1 and 2 with new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'carrot', 'mango', 'banana']"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruitlist #after change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruitlist[1:3] = [\"orange\"] #changing index 1 and 2 with new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'orange', 'banana']"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruitlist #after change"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete List Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can delete list element by index and also by value \n",
    "\n",
    "For deleting element by index we use **del** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "del fruitlist[1] #deleting element at index 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana']"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruitlist  #after update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For deleting elements by element itself we use **remove( )**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 'maths', 2000]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subject_and_year_list #list before removing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "Subject_and_year_list.remove(2000) #removing element i.e 2000 in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['physics', 'chemistry', 'maths']"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subject_and_year_list #after removing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic List Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply any list with any number it repeats all the elements in list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [\"Hi\",2] #new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi', 2, 'Hi', 2, 'Hi', 2]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1*3 #repeatation of list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [3] #new list with one variable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 3, 3]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2*3 #repeatation of list "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to check whether an element in the list or not we simply use **in**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "list3 = [1,2,3] #new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in list3 #cheching if number 2 is in the list or not, it returns boolen value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to merge or concatinate 2 list we simply use **+** operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "list4  = [1, 2, 3] #defining new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "list5 =  [4, 5, 6] #defining new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list4 + list5 #concating 2 list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to find the length of a list we use **len( )**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "list6 = [1,2,3,4] #new list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list6) #finding length of list "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = ('physics', 'chemistry', 1997, 2000) #new tuple\n",
    "tup2 = (1, 2, 3, 4, 5 ) #new tuple\n",
    "tup3 = \"a\", \"b\", \"c\", \"d\" #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('physics', 'chemistry', 1997, 2000) (1, 2, 3, 4, 5) ('a', 'b', 'c', 'd')\n"
     ]
    }
   ],
   "source": [
    "print(tup1,tup2,tup3) #printing tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Values in Tuples\n",
    "For selecting any value we use the square brackets for slicing along with the index or indices to obtain value available at that index\n",
    "\n",
    "#### Selecting only 1 value \n",
    "\n",
    "tuple_name \\[ index ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('physics', 'chemistry', 1997, 2000)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1997"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup1[2] #selecting element of tuple at index 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Selecting multiple value \n",
    "\n",
    "tuple_name \\[ Start_index : End_index-1 ]\n",
    "\n",
    "i.e. from index 1 to 3, it starts from index 1 and end at last range-1  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup3 #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('b', 'c')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup3[1:3] #selecting new range of tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Tuples\n",
    "Tuples are immutable which means you cannot update or change the values of tuple elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete Tuple Elements\n",
    "Removing individual tuple elements is not possible.\n",
    "\n",
    "But we can delete a comple tuple by using **del**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'd')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup3 #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "del tup3 #del is a keyword deleting tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'tup3' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-f484f3ced80d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtup3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'tup3' is not defined"
     ]
    }
   ],
   "source": [
    "tup3 #tuple is deleted "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Tuples Operations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply any tuple with any number it repeats all the elements in tuple "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = (\"Hi\",2) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hi', 2, 'Hi', 2, 'Hi', 2)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup1*3 #repeatation of tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup2 = (3,2) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 3, 2, 3, 2)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup2*3 #repeatation of tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5)*2 # this is mathematics problem it means 5 * 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5,)*2 # this is tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to check whether an element in the tuple or not we simply use **in**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup3 = (1,2,3) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in tup3 #cheching if number 2 is in the tuple or not, it returns boolen value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to merge or concatinate 2 tuple we simply use **+** operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup4  = (1, 2, 3) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup5 =  (4, 5, 6) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup4 + tup5 #concating new tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have to find the length of a tuple we use **len( )**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup6 = (1,2,3,4) #new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tup6) #finding length of the tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary\n",
    "In Dictionary each key is separated from its value by a colon ( : ), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: { }."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "marks_dict = {\"maths\":34,\"chemistry\":36,\"physics\":32} #initilising Dictinory {Key:Value}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'maths': 34, 'chemistry': 36, 'physics': 32}\n"
     ]
    }
   ],
   "source": [
    "print(marks_dict) #printing dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Values in Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_student_detail = {'Name': 'Sagar', 'Age': 7, 'Class': 'First'} #new dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_student_detail['Name']:  Sagar\n"
     ]
    }
   ],
   "source": [
    "print (\"dict_student_detail['Name']: \", dict_student_detail['Name']) #printing single key walue "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_student_detail['Age']:  7\n"
     ]
    }
   ],
   "source": [
    "print (\"dict_student_detail['Age']: \", dict_student_detail['Age']) #printing single key walue "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_student_detail = {'Name': 'Sagar', 'Age': 7, 'Class': 'First'} #new dict\n",
    "dict_student_detail['Age'] = 8; # update existing entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Sagar', 'Age': 8, 'Class': 'First'}"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_student_detail #after updating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_student_detail['School'] = \"K.V.\"; # Add new entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Sagar', 'Age': 8, 'Class': 'First', 'School': 'K.V.'}"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_student_detail #after adding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete Dictionary Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can either remove individual dictionary elements or clear the entire contents of a dictionary. You can also delete entire dictionary in a single operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**remove individual dictionary elements**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'Name': 'Neji', 'Age': 7, 'Class': 'First'} #new dict\n",
    "del dict1['Name'] #deleting key with name \"name\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Age': 7, 'Class': 'First'}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 #after deleting key "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**remove all entries in dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.clear() #cleaning all data in dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 #after clearing all the data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**delete entire dictionary**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "del dict1 #deleting dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'dict1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-108-e36219336d90>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdict1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'dict1' is not defined"
     ]
    }
   ],
   "source": [
    "dict1 #after deleting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### properties of Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "anime = {'Name': 'Naruto', 'Age': 17, 'Class': 'Chunin'} #new dict "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**keys of dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Name', 'Age', 'Class'])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anime.keys() #dict keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Name', 'Age', 'Class']"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(anime.keys()) #converting it into list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Values of Dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Naruto', 17, 'Chunin'])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anime.values() #dict values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Naruto', 17, 'Chunin']"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(anime.values())  #converting it into list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**keys and values of Dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Name', 'Naruto'), ('Age', 17), ('Class', 'Chunin')])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anime.items() #dict items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Name', 'Naruto'), ('Age', 17), ('Class', 'Chunin')]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(anime.items())  #converting it into list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OrderedDict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually dictionary doesn't follow order but we can make dictionary that can follow the order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import collections\n",
    "\n",
    "# print ('Regular dictionary:')\n",
    "# d = {}\n",
    "# d['a'] = 'A'\n",
    "# d['b'] = 'B'\n",
    "# d['c'] = 'C'\n",
    "# d['d'] = 'D'\n",
    "# d['e'] = 'E'\n",
    "\n",
    "# for k, v in d.items():\n",
    "#     print (k, v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "OrderedDict:\n",
      "Keys:  a   Values:  A\n",
      "Keys:  b   Values:  B\n",
      "Keys:  c   Values:  C\n",
      "Keys:  d   Values:  D\n",
      "Keys:  e   Values:  E\n"
     ]
    }
   ],
   "source": [
    "import collections  #this lib has function OrderedDict that make dict in an order \n",
    "print ('\\nOrderedDict:')\n",
    "d = collections.OrderedDict() #defining order dict \n",
    "d['a'] = 'A' #assigning values\n",
    "d['b'] = 'B'\n",
    "d['c'] = 'C'\n",
    "d['d'] = 'D'\n",
    "d['e'] = 'E'\n",
    "\n",
    "for k, v in d.items():\n",
    "    print (\"Keys: \",k,\"  Values: \", v) #print keys and values "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "The sets in python are typically used for mathematical operations like union, intersection, difference and complement etc. We can create a set, access it’s elements and carry out these mathematical operations\n",
    "\n",
    "### Creating a set\n",
    "A set is created by using the **set( )** function or placing all the elements within a pair of curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sun', 'Fri', 'Thu', 'Tue', 'Sat', 'Mon', 'Wed'}\n"
     ]
    }
   ],
   "source": [
    "Days=set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"]) #making set\n",
    "print(Days) #print set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "Months={\"Jan\",\"Feb\",\"Mar\"} #defining set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Feb', 'Jan', 'Mar'}\n"
     ]
    }
   ],
   "source": [
    "print(Months)  #print(Months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Values in a Set\n",
    "We cannot access individual values in a set. We can only access all the elements together as shown above. But we can also get a list of individual elements by looping through the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun\n",
      "Fri\n",
      "Thu\n",
      "Tue\n",
      "Sat\n",
      "Mon\n",
      "Wed\n"
     ]
    }
   ],
   "source": [
    "Days=set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"])\n",
    " \n",
    "for d in Days:\n",
    "    print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Items to a Set\n",
    "We can add elements to a set by using **add( )** method. Again as discussed there is no specific index attached to the newly added element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sun', 'Fri', 'Thu', 'Tue', 'Sat', 'Mon', 'Wed'}\n"
     ]
    }
   ],
   "source": [
    "Days=set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]) #initilising set \n",
    " \n",
    "Days.add(\"Sun\") #adding new value in set \n",
    "print(Days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing Item from a Set\n",
    "We can remove elements from a set by using **discard( )** method. Again as discussed there is no specific index attached to the newly added element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Fri', 'Thu', 'Tue', 'Sat', 'Mon', 'Wed'}\n"
     ]
    }
   ],
   "source": [
    "Days=set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]) #initilising set \n",
    " \n",
    "Days.discard(\"Sun\") #discarding \"Sun\"\n",
    "print(Days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Union of Sets\n",
    "The union operation on two sets produces a new set containing all the distinct elements from both the sets. In the below example the element “Wed” is present in both the sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sun', 'Fri', 'Thu', 'Tue', 'Sat', 'Mon', 'Wed'}\n"
     ]
    }
   ],
   "source": [
    "DaysA = set([\"Mon\",\"Tue\",\"Wed\"]) #new set 1\n",
    "DaysB = set([\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"]) #new set 2\n",
    "AllDays = DaysA|DaysB #union of set\n",
    "print(AllDays) #printing \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intersection of Sets\n",
    "The intersection operation on two sets produces a new set containing only the common elements from both the sets. In the below example the element “Wed” is present in both the sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Wed'}\n"
     ]
    }
   ],
   "source": [
    "DaysA = set([\"Mon\",\"Tue\",\"Wed\"]) #new set 1\n",
    "DaysB = set([\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"]) #new set 2\n",
    "AllDays = DaysA & DaysB #intersection \n",
    "print(AllDays) #printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Difference of Sets\n",
    "The difference operation on two sets produces a new set containing only the elements from the first set and none from the second set. In the below example the element “Wed” is present in both the sets so it will not be found in the result set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tue', 'Mon'}\n"
     ]
    }
   ],
   "source": [
    "DaysA = set([\"Mon\",\"Tue\",\"Wed\"]) #new set 1\n",
    "DaysB = set([\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"]) #new set 2\n",
    "AllDays = DaysA - DaysB #difference \n",
    "print(AllDays) #printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare Sets\n",
    "We can check if a given set is a subset or superset of another set. The result is True or False depending on the elements present in the sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "DaysA = set([\"Mon\",\"Tue\",\"Wed\"]) #set 1\n",
    "DaysB = set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\",\"Sun\"]) #set 2\n",
    "SubsetRes = DaysA <= DaysB #cheching subset \n",
    "print(SubsetRes) #printing result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "SupersetRes = DaysB >= DaysA #cheching subset \n",
    "print(SupersetRes) #printing result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy\n",
    "- Shallow Copy\n",
    "- Deep Copy\n",
    "\n",
    "import copy<br/>\n",
    "copy.copy(x)<br/>\n",
    "copy.deepcopy(x)<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "New list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "new_list = old_list\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [4, 4, 4]]\n",
      "New list: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [4, 4, 4]]\n"
     ]
    }
   ],
   "source": [
    "old_list.append([4, 4, 4])\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478205000"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478205000"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(old_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Shallow Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "New list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "new_list = copy.copy(old_list)\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]]\n",
      "New list: [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n"
     ]
    }
   ],
   "source": [
    "old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n",
    "new_list = copy.copy(old_list)\n",
    "\n",
    "old_list.append([4, 4, 4])\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 1, 1], [2, 'AA', 2], [3, 3, 3]]\n",
      "New list: [[1, 1, 1], [2, 'AA', 2], [3, 3, 3]]\n"
     ]
    }
   ],
   "source": [
    "old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n",
    "new_list = copy.copy(old_list)\n",
    "\n",
    "old_list[1][1] = 'AA'\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478106376"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(old_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478204104"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478287560"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(old_list[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478287560"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(new_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deep Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n",
      "New list: [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n"
     ]
    }
   ],
   "source": [
    "old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n",
    "new_list = copy.deepcopy(old_list)\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old list: [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]]\n",
      "New list: [[1, 1, 1], [2, 2, 2], [3, 3, 3]]\n"
     ]
    }
   ],
   "source": [
    "old_list[1][0] = 'BB'\n",
    "\n",
    "print(\"Old list:\", old_list)\n",
    "print(\"New list:\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478252296"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(old_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478272904"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478253640"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(old_list[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4478234120"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(new_list[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}