Introduction/Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "\n",
    "In this document, we discuss dictionaries, a powerful data structure in Python that are similar to lists.  While lists contain an array of items, that can be accessed via their index, dictionaries contain key-value pairs.  Much like real dictionaries, Python dictionaries keep track of a certain number of items, as well as their values in a single structure.  We demonstrate this in the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}\n",
    "\n",
    "print(my_dict['a'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we define a dictionary that has five keys: $a,b,c,d$ and $e$.  Whose values are $1,2,3,4$ and $5$ respectively.  We then print out the value that corresponds to the key $a$.  Dictionaries are often used for counting objects, we do this in the following example, where we read through a string and count the number of times each letter appears:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = {}\n",
    "\n",
    "string = \"Here is some string of information that we will use for counting.  We will count the number of each letter that appears in this string.\"\n",
    "\n",
    "for letter in string:\n",
    "    if letter in counts.keys():\n",
    "        counts[letter] = counts[letter] + 1\n",
    "    else:\n",
    "        counts[letter] = 1\n",
    "\n",
    "print(counts['a'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will prove a very useful feature of Python, especially when we talk about frequency analysis when tring to crack a shift cipher without the use of brute force.  \n",
    "\n",
    "It is also interesting to note that the keys and values can be pretty much whatever we need them to be.  We demonstrate this in the next example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'b': \"This is a list\", \n",
    "           \"string\": \"This is a string\", \n",
    "           14: [\"nothing\", 45, 9209],\n",
    "           23.4: \"This is a decimal\"}\n",
    "\n",
    "print(f\"The value of my_dict[14] is: {my_dict[14]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A note about this, there are a few things that may not be used as keys.  In order to be used as a key, an object has \n",
    "to be hashable.  A hash is a unique value for each key that is computed and then used to look through the dictionary. We do not need to know to much about this execpt for the fact that any hashable object may be used as a key.  Hashable types include:\n",
    "\n",
    "* int's\n",
    "* str (string)\n",
    "* decimal numbers\n",
    "* Groups inherited from SageMath\n",
    "* tuples\n",
    "* and others\n",
    "\n",
    "Unhashable types include \n",
    "\n",
    "* lists\n",
    "* dictionaries\n",
    "* and others\n",
    "\n",
    "Thus we cannot use these types as keys in our dictionaries.  We can also use iteration to access all the elements in a dictionary just like we did with lists.  There are a few differences to this though; dictionaries offer a few different ways of accessing their elements:\n",
    "\n",
    "* The `.keys()` method, which retuns a list of all the key values in the dictionary\n",
    "* The `.values()` method, which returns a list of all the values in the dictionary\n",
    "* The `.items()` method, which returns a list of tuples containing each key-value pair in the dictionary.  \n",
    "\n",
    "We demonstrate all three of these in the example that follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {}\n",
    "\n",
    "x = [i^3 for i in range(0,15)]\n",
    "y = [i for i in range(0,15)]\n",
    "\n",
    "for i in range(0,len(y)):\n",
    "    my_dict[f\"{i}^3\"] = x[i]\n",
    "\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in my_dict.keys():\n",
    "    print(k)\n",
    "for v in my_dict.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One note about using the `.items()` method.  We will use this most when we wish to access both the key and its value for every element in the dictionary.  In doing so, since this method returns a list of tuples, we need not one but two iterators to accomplish this.  We show how this is done in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k,v in my_dict.items():\n",
    "    print(f\"The value of {k} is {v}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use dictionaries quite a bit throughout this project, so practice using these as we will use them in the future to count cosets, conjugacy classes, and more."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.8",
   "language": "sage",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}