Python Crash Course Dictionaries Sandbox.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "In this video, we'll be discussing Dictionaries. It will be the last among the advanced data types we will be covering in this course.\n",
    "\n",
    "The **dictionary** is among the most powerful data types in Python and is one of my favorites.\n",
    "\n",
    "In Python, dictionaries, like sets, are mutable, unordered collections of items.\n",
    "\n",
    "Metaphor: In regular dictionaries, you **look up** the meaning (\"the value\") for the given word (\"the key\").\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'username': 'joben@example.com'}\n"
     ]
    }
   ],
   "source": [
    "# demo: create a dictionary\n",
    "d1 = {\"username\":\"joben@example.com\"}\n",
    "print(d1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'username': 'joben@example.com', 'first name': 'Joben', 'last name': 'Ilagan'}\n"
     ]
    }
   ],
   "source": [
    "# demo: set new key/value pair\n",
    "\n",
    "d1[\"first name\"]=\"Joben\"\n",
    "d1[\"last name\"]=\"Ilagan\"\n",
    "print(d1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joben\n"
     ]
    }
   ],
   "source": [
    "# demo: retrieve value for a given key\n",
    "\n",
    "print(d1[\"first name\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key does not exist\n",
      "Key does not exist\n"
     ]
    }
   ],
   "source": [
    "# demo: error referencing a non-existent key\n",
    "try:\n",
    "    print(d1[\"address\"])\n",
    "except:\n",
    "    print(\"Key does not exist\")\n",
    "\n",
    "try:\n",
    "    # demo: use a misspelled key\n",
    "    print(d1[\"first_name\"])\n",
    "except:\n",
    "    print(\"Key does not exist\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each item has a key used to reference a value. It's like a variable in this sense. A valid key could be anything immutable like a string, an integer, a boolean, or a tuple. Lists and sets cannot be used as keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'some strong': 'Value 1', 2: 'Value 2', (1, 2): 'Value 3'}\n"
     ]
    }
   ],
   "source": [
    "# demo: valid use of keys\n",
    "d2 = {}\n",
    "\n",
    "# string (common way)\n",
    "d2[\"some strong\"]=\"Value 1\"\n",
    "\n",
    "# integers (also common)\n",
    "\n",
    "d2[2]=\"Value 2\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid operation\n"
     ]
    }
   ],
   "source": [
    "# demo: error using mutable types as keys\n",
    "\n",
    "try:\n",
    "    d2[[\"a\",\"b\"]] = \"a\"\n",
    "except:\n",
    "    print(\"Invalid operation\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demo: mixed key types (not recommended)\n",
    "\n",
    "# uncommon ways\n",
    "d2[(1,2)]=\"Value 3\"\n",
    "\n",
    "print(d2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary values, however, could be any data type or anything referenceable by name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demo: basic datatypes as values\n",
    "d3 = dict()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'firstname': 'Joben', 'lastname': 'Ilagan', 'list demo': ['a', 'b', 'c'], 'set demo': {1, 2, 3, 4, 5}, 'dict demo': {'a': 1, 'b': 2}, 'func demo': <function f1 at 0x7fbdc50d9d40>}\n"
     ]
    }
   ],
   "source": [
    "# demo: more complex data types\n",
    "\n",
    "# lists\n",
    "d3[\"list demo\"] = [\"a\",\"b\",\"c\"]\n",
    "\n",
    "# sets\n",
    "d3[\"set demo\"] = {1,2,3,4,5}\n",
    "\n",
    "# dictionaries (embedded dictionaries)\n",
    "d3[\"dict demo\"] = {\"a\":1,\"b\":2}\n",
    "\n",
    "# functions\n",
    "def f1():\n",
    "    pass\n",
    "\n",
    "d3[\"func demo\"] = f1\n",
    "\n",
    "print(d3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The `dict()` constructor\n",
    "\n",
    "The dict() constructor builds dictionaries directly from sequences of key-value pairs:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demo: dict()\n",
    "\n",
    "d = dict([(1,\"one\"),(2,\"two\")])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `keys()`\n",
    "\n",
    "Return the keys of a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['username', 'first name', 'last name'])\n",
      "['username', 'first name', 'last name']\n"
     ]
    }
   ],
   "source": [
    "# demo: keys()\n",
    "print(d1.keys())\n",
    "\n",
    "# demo: list comprehension/print keys\n",
    "print([d for d in d1.keys()])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `items()`\n",
    "\n",
    "Return a list of tuples of key/value pairs of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('username', 'joben@example.com'), ('first name', 'Joben'), ('last name', 'Ilagan')])\n",
      "[('username', 'joben@example.com'), ('first name', 'Joben'), ('last name', 'Ilagan')]\n"
     ]
    }
   ],
   "source": [
    "# demo: items()\n",
    "print(d1.items())\n",
    "\n",
    "# demo: list comprehension/print items\n",
    "print([d for d in d1.items()])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `values()`\n",
    "\n",
    "Return a list of values of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['joben@example.com', 'Joben', 'Ilagan'])\n",
      "['joben@example.com', 'Joben', 'Ilagan']\n"
     ]
    }
   ],
   "source": [
    "# demo: values()\n",
    "\n",
    "print(d1.values())\n",
    "\n",
    "# demo: list comprehension/print items\n",
    "print([d for d in d1.values()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `get()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joben@example.com\n",
      "Joben\n"
     ]
    }
   ],
   "source": [
    "# demo: get()\n",
    "\n",
    "print(d1.get(\"username\"))\n",
    "print(d1.get(\"first name\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `setdefault()`\n",
    "\n",
    "Returns the value of the specified key. If the key does not exist: insert the key, with the specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    d1[\"nickname\"]\n",
    "except:\n",
    "    pass\n",
    "\n",
    "\n",
    "# demo: setdefault() - new key\n",
    "nickname=d1.setdefault(\"nickname\")\n",
    "print(nickname)\n",
    "\n",
    "# demo: setdefault() - existing key\n",
    "\n",
    "\n",
    "# demo: setdefault() - create new key/value\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex Dictionary Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# product catalog:\n",
    "\n",
    "products_dict = {\"americano\": {\"name\":\"Americano\", \"price\":140},\n",
    "                 \"brewed\":{\"name\":\"Brewed Coffee\", \"price\":100},\n",
    "                 \"cappuccino\":{\"name\":\"Cappuccino\", \"price\":110},\n",
    "                 \"dalgona\":{\"name\":\"Dalgona\", \"price\":120},\n",
    "                 \"espresso\":{\"name\":\"Espresso\", \"price\":110}\n",
    "                }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'americano': {'name': 'Americano', 'price': 140},\n",
       " 'brewed': {'name': 'Brewed Coffee', 'price': 100},\n",
       " 'cappuccino': {'name': 'Cappuccino', 'price': 110},\n",
       " 'dalgona': {'name': 'Dalgona', 'price': 120},\n",
       " 'espresso': {'name': 'Espresso', 'price': 110}}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list products\n",
    "\n",
    "products_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Americano', 'price': 140}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get product\n",
    "products_dict['americano']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get price\n",
    "products_dict['brewed']['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add product\n",
    "products_dict[\"frapuccino\"] = {\"name\":\"Frapuccino\",\"price\":200}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'americano': {'name': 'Americano', 'price': 140},\n",
       " 'brewed': {'name': 'Brewed Coffee', 'price': 100},\n",
       " 'cappuccino': {'name': 'Cappuccino', 'price': 110},\n",
       " 'dalgona': {'name': 'Dalgona', 'price': 120},\n",
       " 'espresso': {'name': 'Espresso', 'price': 110},\n",
       " 'frapuccino': {'name': 'Frapuccino', 'price': 200}}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "products_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[140, 100, 110, 120, 110, 200]\n"
     ]
    }
   ],
   "source": [
    "# get a list of prices\n",
    "print([p[\"price\"] for p in products_dict.values()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the average price of all products\n",
    "sum([p[\"price\"] for p in products_dict.values()])/len(products_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More complex examples: run function dynamically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regular_price(price):\n",
    "    return price\n",
    "\n",
    "def sc_price(price):\n",
    "    return price * 0.8\n",
    "\n",
    "price_tiers = {\"REG\":regular_price,\"SC\":sc_price}\n",
    "\n",
    "customers = {\"joben@example.com\":{\"name\":\"Joben Ilagan\",\"tier\":\"SC\"}, \n",
    "             \"joe@example.com\":{\"name\":\"Joe Ilagan\",\"tier\":\"REG\"},\n",
    "             \"chums@example.com\":{\"name\":\"Matthew Uy\",\"tier\":\"REG\"}\n",
    "            }\n",
    "\n",
    "def quote_price(customer_id, product_id):\n",
    "    \n",
    "    tier = customers[customer_id][\"tier\"]\n",
    "    price_func = price_tiers[tier]\n",
    "    base_price = products_dict[product_id][\"price\"]\n",
    "    print(price_func(base_price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80.0\n"
     ]
    }
   ],
   "source": [
    "quote_price(\"joben@example.com\",\"brewed\")"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}