3. Data Structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data structures are just a way of storing data. Till now we have seen data types: `int`, `String` now we will see how to store and process a combination of these data types.\n",
    "\n",
    "Types of data structures:\n",
    "\n",
    "1. Dictionaries\n",
    "2. Tuples\n",
    "3. Arrays\n",
    "\n",
    "**Tuples** and **Arrays** both contain **ordered** sequence of elements(i.e elements can be accessed using index). **Dictionaries** and **Arrays** both are **mutable**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 2 entries:\n",
       "  \"Harry Cooper\" => \"189-2233\"\n",
       "  \"Julia Potter\" => \"234-11135\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can intialize dictionary we use \"Dict\" keyword\n",
    "phone_book = Dict(\"Julia Potter\" => \"234-11135\",\"Harry Cooper\" => \"189-2233\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 3 entries:\n",
       "  \"Sheldon Nemoy\" => \"234-1112\"\n",
       "  \"Harry Cooper\"  => \"189-2233\"\n",
       "  \"Julia Potter\"  => \"234-11135\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can add another entry as:\n",
    "phone_book[\"Sheldon Nemoy\"] = \"234-1112\"\n",
    "phone_book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"234-11135\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And we can access any element as\n",
    "phone_book[\"Julia Potter\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Sheldon Nemoy\" => \"234-1112\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use \"pop\" function to delete the last added key value pair\n",
    "pop!(phone_book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 2 entries:\n",
       "  \"Harry Cooper\" => \"189-2233\"\n",
       "  \"Julia Potter\" => \"234-11135\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And now when we see the dictionary\n",
    "phone_book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"234-11135\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also delete specific key-value pair as follows\n",
    "pop!(phone_book, \"Julia Potter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,String} with 1 entry:\n",
       "  \"Harry Cooper\" => \"189-2233\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phone_book"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "A tuple can be created by enclosing elements between `( )`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"Harry Porter\", \"Sabrina Spellman\", \"Julia Wicker\", \"Quentin Coldwater\")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people_names = (\"Harry Porter\", \"Sabrina Spellman\",\"Julia Wicker\", \"Quentin Coldwater\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Harry Porter\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people_names[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: Indexing in Julia starts with 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching setindex!(::NTuple{4,String}, ::String, ::Int64)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching setindex!(::NTuple{4,String}, ::String, ::Int64)",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[5]:1"
     ]
    }
   ],
   "source": [
    "# Remember tuples are immutable?\n",
    "people_names[2] = \"Nick Scratch\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array\n",
    "An array can be created by enclosing elements between `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"cat\"\n",
       " \"dog\"\n",
       " \"hamster\"\n",
       " \"bunny\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets = [\"cat\",\"dog\",\"hamster\",\"bunny\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the output of above statement. The first line contains length of array as well as type of elements and dimension of array.\n",
    "\n",
    "The type of elements in this case is string however an array can store any types of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Any,1}:\n",
       "   \"cat\"\n",
       " 42\n",
       "   'c'\n",
       "  2.55"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mix = [\"cat\",42,'c',2.55]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Any,1}:\n",
       "    \"mixmix\"\n",
       "    Any['s', 3455]\n",
       "  33\n",
       " 233.55555\n",
       "    Any[\"cat\", 42, 'c', 2.55]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can even try\n",
    "mix_returns = [\"mixmix\",['s',3455],33,233.55555,mix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"pheonix\"\n",
       " \"dog\"\n",
       " \"hamster\"\n",
       " \"bunny\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remember array is mutable?\n",
    "pets[1] = \"pheonix\"\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add elements by `push!` function and remove by `pop!` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{String,1}:\n",
       " \"pheonix\"\n",
       " \"dog\"\n",
       " \"hamster\"\n",
       " \"bunny\"\n",
       " \"giraffe\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# push! adds new element at the end of array\n",
    "push!(pets,\"giraffe\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"giraffe\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop!(pets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-dimensional arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Array{Int64,1},1}:\n",
       " [1, 7, 3]\n",
       " [9, 4, 6, 8]\n",
       " [45, 5, 9]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = [[1,7,3],[9,4,6,8],[45,5,9]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can also use `rand()` function to create n dimensional array with random values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×4 Array{Float64,2}:\n",
       " 0.79139   0.633849   0.476824  0.559499\n",
       " 0.106785  0.849855   0.125083  0.466247\n",
       " 0.862508  0.0110167  0.429922  0.905755"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create 2D array7 with 3 rows and 4 columns\n",
    "rand(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "OutOfMemoryError",
     "evalue": "OutOfMemoryError()",
     "output_type": "error",
     "traceback": [
      "OutOfMemoryError()",
      "",
      "Stacktrace:",
      " [1] Array at ./boot.jl:417 [inlined]",
      " [2] Array at ./boot.jl:422 [inlined]",
      " [3] rand at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/Random/src/Random.jl:288 [inlined]",
      " [4] rand(::Type{Float64}, ::NTuple{6,Int64}) at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/Random/src/Random.jl:289",
      " [5] rand(::Int64, ::Int64, ::Int64, ::Int64, ::Vararg{Int64,N} where N) at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/Random/src/Random.jl:277",
      " [6] top-level scope at In[1]:1"
     ]
    }
   ],
   "source": [
    "#Your memory may not be able to support this :P\n",
    "rand(100,200,400,900,111,234)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}