Python data structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66ff71d3",
   "metadata": {},
   "source": [
    "# Problem- solving with algorithms - Interactive Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e27163d",
   "metadata": {},
   "source": [
    "Visit https://runestone.academy/runestone/books/published/pythonds/Introduction/GettingStartedwithData.html#built-in-collection-data-types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb126a2b",
   "metadata": {},
   "source": [
    "## Getting Started with Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "149e669f",
   "metadata": {},
   "source": [
    "We stated above that Python supports the object-oriented programming paradigm. This means that Python considers data to be the focal point of the problem-solving process. In Python, as well as in any other object-oriented programming language, we define a class to be a description of what the data look like (the state) and what the data can do (the behavior). Classes are analogous to abstract data types because a user of a class only sees the state and behavior of a data item. Data items are called objects in the object-oriented paradigm. An object is an instance of a class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d01419",
   "metadata": {},
   "source": [
    "## Built-in Atomic Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99c67506",
   "metadata": {},
   "source": [
    "We will begin our review by considering the atomic data types. Python has two main built-in numeric classes that implement the integer and floating point data types. These Python classes are called int and float. The standard arithmetic operations, +, -, *, /, and ** (exponentiation), can be used with parentheses forcing the order of operations away from normal operator precedence. Other very useful operations are the remainder (modulo) operator, %, and integer division, //. Note that when two integers are divided, the result is a floating point. The integer division operator returns the integer portion of the quotient by truncating any fractional part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "179629e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "20\n",
      "1024\n",
      "2.0\n",
      "2.3333333333333335\n",
      "2\n",
      "1\n",
      "0.5\n",
      "0\n",
      "3\n",
      "1267650600228229401496703205376\n"
     ]
    }
   ],
   "source": [
    "print(2+3*4)\n",
    "print((2+3)*4)\n",
    "print(2**10)\n",
    "print(6/3)\n",
    "print(7/3)\n",
    "print(7//3)\n",
    "print(7%3)\n",
    "print(3/6)\n",
    "print(3//6)\n",
    "print(3%6)\n",
    "print(2**100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b34c8486",
   "metadata": {},
   "source": [
    "The boolean data type, implemented as the Python bool class, will be quite useful for representing truth values. The possible state values for a boolean object are True and False with the standard boolean operators, and, or, and not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "97568e62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(False or True)\n",
    "print(not (False or True))\n",
    "print(True and True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2a2ae71d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5==10)\n",
    "print(10 > 5)\n",
    "print((5 >= 1) and (5 <= 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "515ff172",
   "metadata": {},
   "source": [
    "Identifiers are used in programming languages as names. In Python, identifiers start with a letter or an underscore (_), are case sensitive, and can be of any length. Remember that it is always a good idea to use names that convey meaning so that your program code is easier to read and understand.\n",
    "\n",
    "A Python variable is created when a name is used for the first time on the left-hand side of an assignment statement. Assignment statements provide a way to associate a name with a value. The variable will hold a reference to a piece of data and not the data itself. Consider the following session:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01d9661c",
   "metadata": {},
   "source": [
    "## Built-in Collection Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14a476ff",
   "metadata": {},
   "source": [
    "In addition to the numeric and boolean classes, Python has a number of very powerful built-in collection classes. Lists, strings, and tuples are ordered collections that are very similar in general structure but have specific differences that must be understood for them to be used properly. Sets and dictionaries are unordered collections."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17fd28df",
   "metadata": {},
   "source": [
    "A list is an ordered collection of zero or more references to Python data objects. Lists are written as comma-delimited values enclosed in square brackets. The empty list is simply [ ]. Lists are heterogeneous, meaning that the data objects need not all be from the same class and the collection can be assigned to a variable as below. The following fragment shows a variety of Python data objects in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5e1d6e94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, True, 6.5]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,3,True,6.5]"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2e8a77fb",
   "metadata": {},
   "source": [
    "\n",
    "Table 2: Operations on Any Sequence in Python¶\n",
    "Operation Name\n",
    "\n",
    "Operator\n",
    "\n",
    "Explanation\n",
    "\n",
    "indexing\n",
    "\n",
    "[ ]\n",
    "\n",
    "Access an element of a sequence\n",
    "\n",
    "concatenation\n",
    "\n",
    "+\n",
    "\n",
    "Combine sequences together\n",
    "\n",
    "repetition\n",
    "\n",
    "*\n",
    "\n",
    "Concatenate a repeated number of times\n",
    "\n",
    "membership\n",
    "\n",
    "in\n",
    "\n",
    "Ask whether an item is in a sequence\n",
    "\n",
    "length\n",
    "\n",
    "len\n",
    "\n",
    "Ask the number of items in the sequence\n",
    "\n",
    "slicing\n",
    "\n",
    "[ : ]\n",
    "\n",
    "Extract a part of a sequence\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "65f030bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList = [0] * 6\n",
    "myList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "37d49e76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]\n",
      "[[1, 2, 45, 4], [1, 2, 45, 4], [1, 2, 45, 4]]\n"
     ]
    }
   ],
   "source": [
    "myList = [1,2,3,4]\n",
    "A = [myList]*3\n",
    "print(A)\n",
    "myList[2]=45\n",
    "print(A)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5db7322d",
   "metadata": {},
   "source": [
    "The variable A holds a collection of three references to the original list called myList. Note that a change to one element of myList shows up in all three occurrences in A."
   ]
  },
  {
   "cell_type": "raw",
   "id": "f19c9dc5",
   "metadata": {},
   "source": [
    "\n",
    "Table 3: Methods Provided by Lists in Python\n",
    "Method Name\n",
    "\n",
    "Use\n",
    "\n",
    "Explanation\n",
    "\n",
    "append\n",
    "\n",
    "alist.append(item)\n",
    "\n",
    "Adds a new item to the end of a list\n",
    "\n",
    "insert\n",
    "\n",
    "alist.insert(i,item)\n",
    "\n",
    "Inserts an item at the ith position in a list\n",
    "\n",
    "pop\n",
    "\n",
    "alist.pop()\n",
    "\n",
    "Removes and returns the last item in a list\n",
    "\n",
    "pop\n",
    "\n",
    "alist.pop(i)\n",
    "\n",
    "Removes and returns the ith item in a list\n",
    "\n",
    "sort\n",
    "\n",
    "alist.sort()\n",
    "\n",
    "Modifies a list to be sorted\n",
    "\n",
    "reverse\n",
    "\n",
    "alist.reverse()\n",
    "\n",
    "Modifies a list to be in reverse order\n",
    "\n",
    "del\n",
    "\n",
    "del alist[i]\n",
    "\n",
    "Deletes the item in the ith position\n",
    "\n",
    "index\n",
    "\n",
    "alist.index(item)\n",
    "\n",
    "Returns the index of the first occurrence of item\n",
    "\n",
    "count\n",
    "\n",
    "alist.count(item)\n",
    "\n",
    "Returns the number of occurrences of item\n",
    "\n",
    "remove\n",
    "\n",
    "alist.remove(item)\n",
    "\n",
    "Removes the first occurrence of item\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "274c5154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1024, 3, True, 6.5, False]\n",
      "[1024, 3, 4.5, True, 6.5, False]\n",
      "False\n",
      "[1024, 3, 4.5, True, 6.5]\n",
      "3\n",
      "[1024, 4.5, True, 6.5]\n",
      "[1024, 4.5, 6.5]\n",
      "[4.5, 6.5, 1024]\n",
      "[1024, 6.5, 4.5]\n",
      "1\n",
      "2\n",
      "[1024, 4.5]\n",
      "[4.5]\n"
     ]
    }
   ],
   "source": [
    "myList = [1024, 3, True, 6.5]\n",
    "myList.append(False)\n",
    "print(myList)\n",
    "myList.insert(2,4.5)\n",
    "print(myList)\n",
    "print(myList.pop())\n",
    "print(myList)\n",
    "print(myList.pop(1))\n",
    "print(myList)\n",
    "myList.pop(2)\n",
    "print(myList)\n",
    "myList.sort()\n",
    "print(myList)\n",
    "myList.reverse()\n",
    "print(myList)\n",
    "print(myList.count(6.5))\n",
    "print(myList.index(4.5))\n",
    "myList.remove(6.5)\n",
    "print(myList)\n",
    "del myList[0]\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c02edc3",
   "metadata": {},
   "source": [
    "You can see that some of the methods, such as pop, return a value and also modify the list. Others, such as reverse, simply modify the list with no return value. pop will default to the end of the list but can also remove and return a specific item. The index range starting from 0 is again used for these methods. You should also notice the familiar “dot” notation for asking an object to invoke a method. myList.append(False) can be read as “ask the object myList to perform its append method and send it the value False.” Even simple data objects such as integers can invoke methods in this way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d60af449",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "75"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(54).__add__(21)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "226c6d33",
   "metadata": {},
   "source": [
    "One common Python function that is often discussed in conjunction with lists is the range function. range produces a range object that represents a sequence of values. By using the list function, it is possible to see the value of the range object as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "51832267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6fa235b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7371212a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a5ebec00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4, 3, 2]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10,1,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0bca0de",
   "metadata": {},
   "source": [
    "### Strings \n",
    " are sequential collections of zero or more letters, numbers and other symbols. We call these letters, numbers and other symbols characters. Literal string values are differentiated from identifiers by using quotation marks (either single or double)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "83c3ff18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'David'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"David\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d39c9f17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName = \"David\"\n",
    "myName[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "41e518ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'DavidDavid'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5c84cdb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(myName)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "83fdc353",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'DAVID'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b8d50cba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  David   '"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName.center(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a2e8f6de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName.find('v')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "edd7dd70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Da', 'id']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName.split('v') #  split will take a string and return a list of strings using the split character as a division point."
   ]
  },
  {
   "cell_type": "raw",
   "id": "aa1db1e6",
   "metadata": {},
   "source": [
    "Table 4: Methods Provided by Strings in Python\n",
    "Method Name\n",
    "\n",
    "Use\n",
    "\n",
    "Explanation\n",
    "\n",
    "center\n",
    "\n",
    "astring.center(w)\n",
    "\n",
    "Returns a string centered in a field of size w\n",
    "\n",
    "count\n",
    "\n",
    "astring.count(item)\n",
    "\n",
    "Returns the number of occurrences of item in the string\n",
    "\n",
    "ljust\n",
    "\n",
    "astring.ljust(w)\n",
    "\n",
    "Returns a string left-justified in a field of size w\n",
    "\n",
    "lower\n",
    "\n",
    "astring.lower()\n",
    "\n",
    "Returns a string in all lowercase\n",
    "\n",
    "rjust\n",
    "\n",
    "astring.rjust(w)\n",
    "\n",
    "Returns a string right-justified in a field of size w\n",
    "\n",
    "find\n",
    "\n",
    "astring.find(item)\n",
    "\n",
    "Returns the index of the first occurrence of item\n",
    "\n",
    "split\n",
    "\n",
    "astring.split(schar)\n",
    "\n",
    "Splits a string into substrings at schar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3eaff0a",
   "metadata": {},
   "source": [
    "A major difference between lists and strings is that lists can be modified while strings cannot. This is referred to as mutability. Lists are mutable; strings are immutable. For example, you can change an item in a list by using indexing and assignment. With a string that change is not allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2775afec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, True, 6.5]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList = [1, 3, True, 6.5]\n",
    "myList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "bfe2ef4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1024, 3, True, 6.5]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList[0]=2**10\n",
    "myList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c32b22d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'David'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5042ebf3",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-b5f97be68ffa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyName\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'X'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "myName[0]='X'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a11c7b",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "are very similar to lists in that they are heterogeneous sequences of data. The difference is that a tuple is immutable, like a string. A tuple cannot be changed. Tuples are written as comma-delimited values enclosed in parentheses. As sequences, they can use any operation described above. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7b0a29ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "myTuple = (2,True,4.96)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a32deb26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, True, 4.96)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b42eb5d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, True, 4.96, 2, True, 4.96, 2, True, 4.96)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTuple * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05bc33a9",
   "metadata": {},
   "source": [
    "However, if you try to change an item in a tuple, you will get an error. Note that the error message provides location and reason for the problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "89b465a2",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-40-9ce44eca4013>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmyTuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "myTuple[1]=False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcc07a9c",
   "metadata": {},
   "source": [
    "## set \n",
    "is an unordered collection of zero or more immutable Python data objects. Sets do not allow duplicates and are written as comma-delimited values enclosed in curly braces. The empty set is represented by set(). Sets are heterogeneous, and the collection can be assigned to a variable as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "24c48811",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4.5, 6, False, 'cat'}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{3,6,\"cat\",4.5,False}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1c394701",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySet = {3,6,\"cat\",4.5,False}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "fb8c7a0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4.5, 6, False, 'cat'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ffe3f72d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False in mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "025c17be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"dog\" in mySet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6c43ad9",
   "metadata": {},
   "source": [
    "Sets support a number of methods that should be familiar to those who have worked with them in a mathematics setting. Table 6 provides a summary. Examples of their use follow. Note that union, intersection, issubset, and difference all have operators that can be used as well."
   ]
  },
  {
   "cell_type": "raw",
   "id": "06484e2b",
   "metadata": {},
   "source": [
    "\n",
    "Table 6: Methods Provided by Sets in Python\n",
    "Method Name\n",
    "\n",
    "Use\n",
    "\n",
    "Explanation\n",
    "\n",
    "union\n",
    "\n",
    "aset.union(otherset)\n",
    "\n",
    "Returns a new set with all elements from both sets\n",
    "\n",
    "intersection\n",
    "\n",
    "aset.intersection(otherset)\n",
    "\n",
    "Returns a new set with only those elements common to both sets\n",
    "\n",
    "difference\n",
    "\n",
    "aset.difference(otherset)\n",
    "\n",
    "Returns a new set with all items from first set not in second\n",
    "\n",
    "issubset\n",
    "\n",
    "aset.issubset(otherset)\n",
    "\n",
    "Asks whether all elements of one set are in the other\n",
    "\n",
    "add\n",
    "\n",
    "aset.add(item)\n",
    "\n",
    "Adds item to the set\n",
    "\n",
    "remove\n",
    "\n",
    "aset.remove(item)\n",
    "\n",
    "Removes item from the set\n",
    "\n",
    "pop\n",
    "\n",
    "aset.pop()\n",
    "\n",
    "Removes an arbitrary element from the set\n",
    "\n",
    "clear\n",
    "\n",
    "aset.clear()\n",
    "\n",
    "Removes all elements from the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "04cd666e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4.5, 6, False, 'cat'}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "82c91539",
   "metadata": {},
   "outputs": [],
   "source": [
    "yourSet = {99,3,100}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6bb775d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{100, 3, 4.5, 6, 99, False, 'cat'}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet.union(yourSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "b7136ac7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{100, 3, 4.5, 6, 99, False, 'cat'}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet | yourSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6dd7ce44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet.intersection(yourSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9ca2a207",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4.5, 6, False, 'cat'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet.difference(yourSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "01986153",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4.5, 6, False, 'cat'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet - yourSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "fe4f5d7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{3,100}.issubset(yourSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "7d6dca33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{3,100}<=yourSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "85b5bd99",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySet.add(\"house\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "35af6d4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4.5, 6, False, 'cat', 'house'}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "6a7ce2ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySet.remove(4.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d30822e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 6, False, 'cat', 'house'}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "7a71bf97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "25e33dcf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 6, 'cat', 'house'}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "cb5fa049",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySet.clear()\n",
    "mySet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e970ef48",
   "metadata": {},
   "source": [
    "Our final Python collection is an unordered structure called a dictionary. Dictionaries are collections of associated pairs of items where each pair consists of a key and a value. This key-value pair is typically written as key:value. Dictionaries are written as comma-delimited key:value pairs enclosed in curly braces. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "db7fee6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Iowa': 'DesMoines', 'Wisconsin': 'Madison'}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}\n",
    "capitals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02737ff9",
   "metadata": {},
   "source": [
    "We can manipulate a dictionary by accessing a value via its key or by adding another key-value pair. The syntax for access looks much like a sequence access except that instead of using the index of the item we use the key value. To add a new value is similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ed3e5f4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DesMoines\n"
     ]
    }
   ],
   "source": [
    "print(capitals['Iowa'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "5763201a",
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals['Utah']='SaltLakeCity'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ddd6182f",
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals['California']='Sacramento'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "b05df1a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(capitals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "12a4adcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DesMoines  is the capital of  Iowa\n",
      "Madison  is the capital of  Wisconsin\n",
      "SaltLakeCity  is the capital of  Utah\n",
      "Sacramento  is the capital of  California\n"
     ]
    }
   ],
   "source": [
    "for k in capitals:\n",
    "   print(capitals[k],\" is the capital of \", k)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a3b81c8f",
   "metadata": {},
   "source": [
    "\n",
    "Table 7: Operators Provided by Dictionaries in Python¶\n",
    "Operator\n",
    "\n",
    "Use\n",
    "\n",
    "Explanation\n",
    "\n",
    "[]\n",
    "\n",
    "myDict[k]\n",
    "\n",
    "Returns the value associated with k, otherwise its an error\n",
    "\n",
    "in\n",
    "\n",
    "key in adict\n",
    "\n",
    "Returns True if key is in the dictionary, False otherwise\n",
    "\n",
    "del\n",
    "\n",
    "del adict[key]\n",
    "\n",
    "Removes the entry from the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2266afd5",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}