Introduction to Julia/Data-Structures.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures\n",
    "\n",
    "Once we start working with many pieces of data at once, it will be convenient for us to store data in structures like arrays or dictionaries (rather than just relying on variables).\n",
    "\n",
    "Types of data structures covered:\n",
    "\n",
    "1. Tuples\n",
    "2. Dictionaries\n",
    "3. Arrays\n",
    "\n",
    "As an overview, tuples and arrays are both ordered sequences of elements (so we can index into them). Dictionaries and arrays are both mutable. We'll explain this more below!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Tuples*\n",
    "\n",
    "We can create a tuple by enclosing an ordered collection of elements in `( )`.\n",
    "\n",
    "Syntax:\n",
    "```julia\n",
    "(item1, item2, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"badminton\", \"chess\", \"swimming\")"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfavoritesports = (\"badminton\", \"chess\", \"swimming\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index this tuple,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"badminton\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfavoritesports[1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but since tuples are immutable, we can't update it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching setindex!(::Tuple{String, String, String}, ::String, ::Int64)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching setindex!(::Tuple{String, String, String}, ::String, ::Int64)",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[3]:1",
      " [2] eval",
      "   @ .\\boot.jl:368 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1428"
     ]
    }
   ],
   "source": [
    "myfavoritesports[1] = \"running\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NamedTuples"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might guess, `NamedTuples` are just like `Tuples` except that each element additionally has a name! They have a special syntax using = inside a tuple:\n",
    "```julia\n",
    "(name1 = item1, name2 = item2, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(phone = \"iphone\", laptop = \"macbook\", monitor = \"imac\")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystuffs = (phone = \"iphone\", laptop = \"macbook\", monitor = \"imac\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like regular `Tuples`, `NamedTuples` are ordered, so we can retrieve their elements via indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"iphone\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystuffs[1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They also add the special ability to access values by their name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"iphone\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystuffs.phone"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Dictionaries*\n",
    "\n",
    "If we have sets of data related to one another, we may choose to store that data in a dictionary. We can create a dictionary using the `Dict()` function, which we can initialize as an empty dictionary or one storing key, value pairs.\n",
    "\n",
    "Syntax:\n",
    "```julia\n",
    "Dict(key1 => value1, key2 => value2, ...)\n",
    "```\n",
    "A good example is a contacts list, where we associate names with phone numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, String} with 2 entries:\n",
       "  \"Lee\"    => \"867-5309\"\n",
       "  \"Ichigo\" => \"555-2368\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook = Dict(\"Lee\" => \"867-5309\", \"Ichigo\" => \"555-2368\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, each name and number is a \"`key`\" and \"`value`\" pair. We can grab Ichigo's number (a value) using the associated key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"555-2368\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook[\"Ichigo\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add another entry to this dictionary as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"555-FILK\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook[\"Kaneki\"] = \"555-FILK\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check what our phonebook looks like now..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, String} with 3 entries:\n",
       "  \"Lee\"    => \"867-5309\"\n",
       "  \"Kaneki\" => \"555-FILK\"\n",
       "  \"Ichigo\" => \"555-2368\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can delete Kramer from our contact list - and simultaneously grab his number - by using `pop!`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"555-FILK\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop!(myphonebook, \"Kaneki\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, String} with 2 entries:\n",
       "  \"Lee\"    => \"867-5309\"\n",
       "  \"Ichigo\" => \"555-2368\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike `tuples` and `arrays`, dictionaries are not ordered. So, we can't index into them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "KeyError: key 1 not found",
     "output_type": "error",
     "traceback": [
      "KeyError: key 1 not found",
      "",
      "Stacktrace:",
      " [1] getindex(h::Dict{String, String}, key::Int64)",
      "   @ Base .\\dict.jl:498",
      " [2] top-level scope",
      "   @ In[15]:1",
      " [3] eval",
      "   @ .\\boot.jl:368 [inlined]",
      " [4] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1428"
     ]
    }
   ],
   "source": [
    "myphonebook[1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, `julia` thinks you're trying to access a value associated with the key 1."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Arrays*"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike tuples, arrays are mutable. Unlike dictionaries, arrays contain ordered collections.\n",
    "We can create an array by enclosing this collection in `[ ]`.\n",
    "\n",
    "Syntax:\n",
    "```Julia\n",
    "[item1, item2, ...]\n",
    "```\n",
    "For example, we might create an array to keep track of my friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{String}:\n",
       " \"Lee\"\n",
       " \"Ichigo\"\n",
       " \"Kaneki\"\n",
       " \"Anya\"\n",
       " \"Kenpachi\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfriends = [\"Lee\", \"Ichigo\", \"Kaneki\", \"Anya\", \"Kenpachi\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `1` in `Array{String,1}` means this is a *one dimensional vector*. An `Array{String,2}` would be a *2d matrix*, etc. The String is the type of each element.\n",
    "\n",
    "or to store a sequence of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci = [1, 1, 2, 3, 5, 8, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Vector{Any}:\n",
       " 1\n",
       " 1\n",
       " 2\n",
       " 3\n",
       "  \"Lee\"\n",
       "  \"Ichigo\""
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mixture = [1, 1, 2, 3, \"Lee\", \"Ichigo\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have an array, we can grab individual pieces of data from inside that array by indexing into the array. For example, if we want the third friend listed in `myfriends`, we write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Kaneki\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfriends[3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use indexing to edit an existing element of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Kuchiki Rukia\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfriends[3] = \"Kuchiki Rukia\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, `Julia` is 1-based indexing, not 0-based like Python.\n",
    "\n",
    "We can also edit the array by using the `push!` and `pop!` functions. `push!` adds an element to the end of an array and `pop!` removes the last element of an array.\n",
    "\n",
    "We can add another number to our fibonnaci sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13\n",
       " 21"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(fibonacci, 21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop!(fibonacci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far I've given examples of only 1D arrays of scalars, but arrays can have an arbitrary number of dimensions and can also store other arrays.\n",
    "\n",
    "For example, the following are arrays of arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Vector{String}}:\n",
       " [\"Ichigo\", \"Kenpachi\", \"Aizen\"]\n",
       " [\"Lee\", \"Kakashi\", \"Naruto\"]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favorites = [[\"Ichigo\", \"Kenpachi\", \"Aizen\"],[\"Lee\", \"Kakashi\", \"Naruto\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Vector{Int64}}:\n",
       " [1, 2, 3]\n",
       " [4, 5]\n",
       " [6, 7, 8, 9]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below are examples of 2D and 3D arrays populated with random values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×3 Matrix{Float64}:\n",
       " 0.833448  0.59033   0.112962\n",
       " 0.206561  0.435435  0.848888\n",
       " 0.414439  0.397589  0.76593\n",
       " 0.561113  0.263221  0.21591"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand(4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×3×2 Array{Float64, 3}:\n",
       "[:, :, 1] =\n",
       " 0.730082  0.220297  0.204695\n",
       " 0.162849  0.607225  0.599858\n",
       " 0.356808  0.679082  0.807356\n",
       " 0.89063   0.790671  0.472647\n",
       "\n",
       "[:, :, 2] =\n",
       " 0.233223  0.380667  0.61055\n",
       " 0.86556   0.565525  0.882137\n",
       " 0.903787  0.648899  0.0736579\n",
       " 0.946271  0.266761  0.861543"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand(4, 3, 2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful when you want to copy arrays!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "somenumbers = fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "404"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "somenumbers[1] = 404"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       " 404\n",
       "   1\n",
       "   2\n",
       "   3\n",
       "   5\n",
       "   8\n",
       "  13"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Editing `somenumbers` caused `fibonacci` to get updated as well!\n",
    "\n",
    "In the above example, we didn't actually make a copy of `fibonacci`. We just created a new way to access the entries in the array bound to `fibonacci`.\n",
    "\n",
    "If we'd like to make a copy of the array bound to `fibonacci`, we can use the `copy` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First, restore fibonacci\n",
    "fibonacci[1] = 1\n",
    "fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "somemorenumbers = copy(fibonacci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "404"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "somemorenumbers[1] = 404"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this last example, `fibonacci` was not updated. Therefore we see that the arrays bound to `somemorenumbers` and `fibonacci` are distinct."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "1. Create an array, a_ray, with the following code:\n",
    "```julia\n",
    "a_ray = [1, 2, 3]\n",
    "```\n",
    "Add the number 4 to the end of this array and then remove it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_ray = [1, 2, 3]\n",
    "\n",
    "# add 4 to a_ray\n",
    "push!(a_ray, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop!(a_ray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "@assert a_ray == [1, 2, 3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Try to add \"Emergency\" as key to `myphonebook` with the value `string(911)` with the following code\n",
    "```julia\n",
    "myphonebook[\"Emergency\"] = 911\n",
    "```\n",
    "Why doesn't this work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, String} with 2 entries:\n",
       "  \"Lee\"    => \"867-5309\"\n",
       "  \"Ichigo\" => \"555-2368\""
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myphonebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: \u001b[0mCannot `convert` an object of type \u001b[92mInt64\u001b[39m\u001b[0m to an object of type \u001b[91mString\u001b[39m\n\u001b[0mClosest candidates are:\n\u001b[0m  convert(::Type{String}, \u001b[91m::String\u001b[39m) at essentials.jl:218\n\u001b[0m  convert(::Type{T}, \u001b[91m::T\u001b[39m) where T<:AbstractString at strings/basic.jl:231\n\u001b[0m  convert(::Type{T}, \u001b[91m::AbstractString\u001b[39m) where T<:AbstractString at strings/basic.jl:232\n\u001b[0m  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: \u001b[0mCannot `convert` an object of type \u001b[92mInt64\u001b[39m\u001b[0m to an object of type \u001b[91mString\u001b[39m\n\u001b[0mClosest candidates are:\n\u001b[0m  convert(::Type{String}, \u001b[91m::String\u001b[39m) at essentials.jl:218\n\u001b[0m  convert(::Type{T}, \u001b[91m::T\u001b[39m) where T<:AbstractString at strings/basic.jl:231\n\u001b[0m  convert(::Type{T}, \u001b[91m::AbstractString\u001b[39m) where T<:AbstractString at strings/basic.jl:232\n\u001b[0m  ...",
      "",
      "Stacktrace:",
      " [1] setindex!(h::Dict{String, String}, v0::Int64, key::String)",
      "   @ Base .\\dict.jl:382",
      " [2] top-level scope",
      "   @ In[42]:1",
      " [3] eval",
      "   @ .\\boot.jl:368 [inlined]",
      " [4] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base .\\loading.jl:1428"
     ]
    }
   ],
   "source": [
    "myphonebook[\"Emergency\"] = 911"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Julia` says : Cannot `convert` an object of type Int64 to an object of type String. it Seems like we've to store a string value to an `Emergency` key, since all `key-value` pairs in `myphonebook` arrays are having all values in string."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Create a new dictionary called `flexible_phonebook` that has Lee's number stored as an integer and Ghostbusters' number stored as a string with the following code\n",
    "```julia\n",
    "flexible_phonebook = Dict(\"Lee\" => 867-5309, \"Ichigo\" => \"555-2368\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, Any} with 2 entries:\n",
       "  \"Lee\"    => 8675309\n",
       "  \"Ichigo\" => \"555-2368\""
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flexible_phonebook = Dict(\"Lee\" => 8675309, \"Ichigo\" => \"555-2368\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "@assert flexible_phonebook == Dict(\"Lee\" => 8675309, \"Ichigo\" => \"555-2368\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Add the key \"Emergency\" with the value `911` (an integer) to `flexible_phonebook`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "911"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flexible_phonebook[\"Emergency\"] = 911"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "@assert haskey(flexible_phonebook, \"Emergency\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "@assert flexible_phonebook[\"Emergency\"] == 911"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Why can we add an integer as a value to `flexible_phonebook` but not `myphonebook`? How could we have initialized myphonebook so that it would accept integers as values? (hint: try using [Julia's documentation for dictionaries](https://docs.julialang.org/en/v1/base/collections/#Dictionaries))\n",
    "\n",
    "Because,<br>\n",
    "when we create `Dict` : `Dict(\"A\"=>1, \"B\"=>2)`, this call will attempt to infer type information from the keys and values (i.e. for `myphonebook` creates a `Dict{String}`, while `flexible_phonebook` creates a `Dict{String,Int32}`). That's why when we add `Emergency` where its value is `Int64` throws an error. cause `Julia` only knows value `strings` for this arrays. (***CMIIW***)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.3",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.3"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "213524bb45a1aeaf737b1d8c77d7b8db5d425938d9dffc5f4bc6fe6dd3324700"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}