Learn Python Variables and Data Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Python Variables and Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**April 2021**<br>\n",
    "\n",
    "Instruction, media content, examples and links to resources that will help you build a foundation for Python competency. Jupyter Notebooks are available on [Google Colab](https://colab.research.google.com/drive/1tdQkjNdHGJ7wTMvO_bhp3aM5k3ZR3eEx?usp=sharing) and [Github](https://github.com/AlphaWaveData/Jupyter-Notebooks/blob/master/Learn%20Python%20Variables%20and%20Data%20Types.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SINGLE DATA TYPES #\n",
    "\n",
    "### Prerequisite knowledge ###\n",
    "- variable assignment using a single equals `=`\n",
    "- variables must use letters first and not numbers e.g. `var_1` and not `1_var`\n",
    "- there are reserved words that cannot be used such as `print`, `str`, `int`....\n",
    "\n",
    "\n",
    "<b>Web Resources</b>\n",
    "<br> <a href='https://docs.python.org/3/tutorial/introduction.html#numbers'>Docs.python.org - Numbers Data Types</a>\n",
    "<br> <a href='https://docs.python.org/3/tutorial/introduction.html#strings'>Docs.python.org - Strings Data Types</a>\n",
    "<br> <a href='https://docs.python.org/3/tutorial/introduction.html#lists'>Docs.python.org - Lists Data Types</a>\n",
    "<br> <a href='https://docs.python.org/3/tutorial/datastructures.html#dictionaries'>Docs.python.org - Dictionary Data Types</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>STRINGS</h2>\n",
    "\n",
    "#### What is a String?####\n",
    "A string is a data type that is used to represent text rather than numbers and is composed of a set of characters and can also contain spaces and numbers.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use Strings?####\n",
    "Strings are useful when storing small or large bodies from single words to full sentences. \n",
    "<br>\n",
    "<br>\n",
    "#### How do we use Strings?####\n",
    "Strings are assigned to variables using a single equals and are surrounded by triple quotes `\"\"\" \"\"\"`, double quotes `\" \"` or single quotes `' '`, although triple quotes are generally used for function doc strings so please use the single or double quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a String ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is also a string\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_1 = \"\"\"This is a string\"\"\"    # triple quote\n",
    "string_2 = \"this is another string\"  # double quote\n",
    "string_3 = 'this is also a string'   # single quote\n",
    "\n",
    "print(string_3)\n",
    "type(string_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing a String ###\n",
    "It is possible to index a string by referencing the position (or index) of a single character, or by referencing a range with a start and end position. Note: indexes start at where the first element is 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string\n",
      "T\n",
      "is a str\n"
     ]
    }
   ],
   "source": [
    "print(string_1)\n",
    "print(string_1[0])\n",
    "print(string_1[5:-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>INTEGERS or INTs</h2>\n",
    "\n",
    "#### What is an Integer?####\n",
    "An integer is a whole number (not a fraction) that can be positive, negative or zero.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use Integers?####\n",
    "Integers are a commonly used data type in programming as they are efficient to store and are generally used in loops and indexing strings or lists. \n",
    "<br>\n",
    "<br>\n",
    "#### How do we use Integers?####\n",
    "Integers are assigned to variables using a single equals and are standalone numbers without a decimal point or an operation that does not return a whole number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 -2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_1 = 1\n",
    "int_2 = -2\n",
    "int_3 = 10 / 2\n",
    "\n",
    "print(int_1, int_2)\n",
    "type(int_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>FLOATING-POINT NUMBERS or FLOATS</h2>\n",
    "\n",
    "#### What is a Float?####\n",
    "A float is a floating-point number that contains a decimal point. Compared to Integers, they require more space in memory as you will have two integers separated by a decimal point.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use Floats?####\n",
    "Computers recognize real numbers that contain fractions as floating point numbers. Floats are useful for numbers that require a great deal of precision, such as calculations in engineering or microchip manufacturing.\n",
    "<br>\n",
    "<br>\n",
    "#### How do we use Floats?####\n",
    "Floats are assigned to variables using a single equals and are standalone numbers that contain a decimal point or the result of an operation that returns a decimal number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 3.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_1 = 1.0\n",
    "float_2 = 3 / 1\n",
    "print(float_1, float_2)\n",
    "type(float_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BASIC DATA STRUCTURES #\n",
    "Now that we have covered single variables being strings, ints and floats, there is another class of variables which store one or more single variables.\n",
    "\n",
    "These are Lists, Dictionaries and Tuples. More information can be found in the python documentation: <br>\n",
    "https://docs.python.org/3/tutorial/datastructures.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>LISTS</h2>\n",
    "\n",
    "#### What is a List?####\n",
    "Lists are data structures that contain an ordered collection of elements. These elements are generally of the same type and can contain elements such as single data types through to more complex data structures such as other lists or dictionaries.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use Lists?####\n",
    "Lists are commonly used in programming to store and organize data so it can be easily sorted, indexed or searched.\n",
    "<br>\n",
    "<br>\n",
    "#### How do we use Lists?####\n",
    "Lists are assigned to variables using a single equals, are denoted by square brackets, and use a comma to separate elements `[a,b]`.\n",
    "\n",
    "### Creating a List ###\n",
    "There are two main ways of creating a list. First is to use square brackets,`a=[]` and the second is to use the list type cast `b=list()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['string item', 1.0, 100]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1 = ['string item',float_1,100]\n",
    "list_a = list()\n",
    "print(list_1)\n",
    "type(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding an item to a List ###\n",
    "Now that we have our list, you can add another element using the python's inbuilt `.append()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['string item', 1.0, 100, 'new element']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1.append('new element')\n",
    "print(list_1)\n",
    "type(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing an item in a List ###\n",
    "When changing an item in a list, you need to know the position of the item denoted by the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['string item', 'Changed Item', 100, 'new element']\n"
     ]
    }
   ],
   "source": [
    "list_1[1]='Changed Item'\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing an item from a List ###\n",
    "To remove an item from a list, use the `.pop()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Changed Item', 100, 'new element']\n"
     ]
    }
   ],
   "source": [
    "list_1.pop(0)\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merging two Lists ###\n",
    "There are two ways you can merge two lists. First is to append using `.append(element)` which will add the new elements to the end of the old list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Changed Item', 100, 'new element', ['this', 'is', 'a', 'list']]\n"
     ]
    }
   ],
   "source": [
    "list_2 = ['this', 'is', 'a', 'list']\n",
    "list_1.append(list_2)\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other way is to insert a list as an element within the list (note: not append but inject) using the `.insert(index, element)` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, [5, 6, 7, 8], 3, 4]\n"
     ]
    }
   ],
   "source": [
    "list_3 = [1,2,3,4]\n",
    "list_4 = [5,6,7,8]\n",
    "list_3.insert(2,list_4)\n",
    "print(list_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing items in a List ###\n",
    "You can access list items by referring to the index number of the item. Note: Lists start with an index of 0. \n",
    "\n",
    "You can also use negative indexing to access items from back to front. E.g. -1 is the last item in the list and -2 is second last."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changed Item\n",
      "['this', 'is', 'a', 'list']\n"
     ]
    }
   ],
   "source": [
    "print(list_1[0])\n",
    "print(list_1[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also reference index ranges by using the colon between indexes which refer to the start and end of the range e.g. `[start:end]` or if you omit a number on either start (or end), it will include everything from the start (or end) up until the end (or start) e.g. `[:end]` will include the first item until the end index item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Changed Item', 100, 'new element']\n",
      "['new element', ['this', 'is', 'a', 'list']]\n"
     ]
    }
   ],
   "source": [
    "print(list_1[0:3])\n",
    "print(list_1[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List of Dictionaries ###\n",
    "The below example illustrates how to create a list of dictionaries (a more complex data structure that will be covered below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'key_1': 'value_1', 'key_2': 'value_2'}, {'key_3': 'value_3', 'key_4': 'value_4'}, {'key_1': 'value_1', 'key_2': 'value_2'}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_a = {'key_1':'value_1',\n",
    "          'key_2':'value_2'}\n",
    "dict_b = {'key_3':'value_3',\n",
    "          'key_4':'value_4'}\n",
    "list_a = [dict_a, dict_b, dict_a]\n",
    "print(list_a)\n",
    "type(list_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also index this list to get the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key_1': 'value_1', 'key_2': 'value_2'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(list_a[0])\n",
    "type(list_a[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension ###\n",
    "List comprehensions provide a concise way to create lists where each new element is the result of some operation applied to each member of another sequence or iterable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [x**2 for x in range(10)]\n",
    "print(squares)\n",
    "type(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>TUPLES</h2>\n",
    "\n",
    "#### What is a Tuple?####\n",
    "A tuple is a data structure that contains an ordered collection of elements that are immutable (unchangeable). These elements are generally of the same type and can contain elements such as single data types through to more complex data structures such as other lists or dictionaries.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use Tuples?####\n",
    "Tuples are commonly used in programming to store and organize data so it can be easily sorted, indexed or searched. Since tuples are immutable, we cannot add, change or remove elements.\n",
    "<br>\n",
    "<br>\n",
    "#### How do we use Tuples?####\n",
    "Tuples are assigned to variables using a single equals and are denoted by round brackets and use a comma to separate elements `(a,b,c)`.\n",
    "\n",
    "### Creating a Tuple ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple_1 = (1,2,3,4)\n",
    "print(tuple_1)\n",
    "type(tuple_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Dictionaries</h2>\n",
    "\n",
    "#### What is a Dictionary?####\n",
    "Dictionaries are data structures that contain a collection of \"key\" and \"value\" pairs where each key needs to be a unique string and the value can range from a single variable, to other data structures (such as another dictionary, or a list). If you attempt to add a new key1:value pair when the key1 already exists in the Dictionary, you should get a KeyExists error or risk overwriting the existing data. Since dictionaries can store single or complex data types as values, you can store two identical types in a list or dictionary structure. For example, a key with three identical values in a list key1:[value1,value1,value1] can be stored in a Dictionary.\n",
    "<br>\n",
    "<br>\n",
    "#### Why do we use a Dictionary?####\n",
    "Dictionaries are commonly used in programming to store and organize data so it can be easily sorted, indexed or searched. Since dictionaries are mutable, we can add, change, or remove elements.\n",
    "<br>\n",
    "<br>\n",
    "#### How do we use a Dictionary?####\n",
    "Dictionaries are assigned to variables using a single equals and are denoted by curly brackets and use a colon to separate key and value, and a comma to separate elements `{key1: value1, key2: value2}`.\n",
    "\n",
    "### Creating a Dictionary ###\n",
    "There are two ways to create an empty dictionary - `my_dict = dict()` or `my_dict = {}`. \n",
    "The following example illustrates how to create a dictionary with keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key_1': 'value_1', 'key_2': 'value_2'}\n",
      "{'key_100': 'item_100', 'key_101': 'item_101'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1 = {'key_1':'value_1',\n",
    "          'key_2':'value_2'}\n",
    "\n",
    "dict_2 = dict(key_100='item_100',key_101='item_101')\n",
    "print(dict_1)\n",
    "print(dict_2)\n",
    "type(dict_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding items to a Dictionary ###\n",
    "Once we have created the dictionary data structure object, the below example shows how to add a new key, value pair where the value is a list from the above example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key_1': 'value_1', 'key_2': 'value_2', 'key_3': 'value_3'}\n"
     ]
    }
   ],
   "source": [
    "dict_1['key_3'] = 'value_3'\n",
    "print(dict_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing items from a Dictionary ###\n",
    "To remove items from a dictionary you can use the `.pop()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key_2': 'value_2', 'key_3': 'value_3'}\n"
     ]
    }
   ],
   "source": [
    "dict_1.pop('key_1')\n",
    "print(dict_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing items in a Dictionary ###\n",
    "To access a value in a dictionary you can use the `.get()` method, which is preferred because if it cannot find the key it will return a `None`.\n",
    "\n",
    "The second method does work but is not considered best practice since python throws `KeyError` and will block a program from continuing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n",
      "value_2\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'key_10'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-36a1e841c17a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# or another way\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict_1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'key_2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict_1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'key_10'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'key_10'"
     ]
    }
   ],
   "source": [
    "# to access the item of a dictionary by its key use the .get() \n",
    "print(dict_1.get('key_1'))\n",
    "print(dict_1.get('key_10'))\n",
    "\n",
    "# or another way\n",
    "print(dict_1['key_2'])\n",
    "print(dict_1['key_10'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing all keys or items of a Dictionary ###\n",
    "It is also possible to output all keys or items to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['key_2', 'key_3']\n",
      "['value_2', 'value_3']\n"
     ]
    }
   ],
   "source": [
    "# to get all keys or values\n",
    "print(list(dict_1.keys()))\n",
    "\n",
    "# or get all values\n",
    "print(list(dict_1.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check if key exists in a Dictionary ###\n",
    "It is always helpful to see if the dictionary contains a specific key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key_1 exists!\n"
     ]
    }
   ],
   "source": [
    "if 'key_2' in dict_1: \n",
    "    print(\"key_1 exists!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the key does not exist\n"
     ]
    }
   ],
   "source": [
    "if 'random_key' in dict_1: \n",
    "    print(\"the key exists!\")\n",
    "else:\n",
    "    print('the key does not exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Comprehension ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares_dict = {x:x**2 for x in range(10)}\n",
    "print(squares_dict)\n",
    "type(squares_dict)"
   ]
  },
  {
   "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": 4
}