chapters/Chapter 7 - Loopin it.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "Many times in python you will find yourself wanting to do something for every element in a collection. \n",
    "This could be applying some transformation to it, printing something, or anything else!\n",
    "\n",
    "Luckily, python makes this very straightforward for us. \n",
    "\n",
    "## For Loops\n",
    "\n",
    "### General syntax: \n",
    "\n",
    "```python\n",
    "for <element> in <iterator>:\n",
    "    # do something!\n",
    "```\n",
    "\n",
    "Before we think about the `element`, we have to think about the `iterator`. \n",
    "What are we iterating over?\n",
    "The answer to this will determine what each `element` will be.\n",
    "\n",
    "<hr>\n",
    "\n",
    "### Definition - What does Iteration mean?\n",
    "\n",
    "\"**_Iteration_**, in the context of computer programming, is a process wherein a set of instructions or structures are repeated in a sequence a specified number of times or until a condition is met. When the first set of instructions is executed again, it is called an iteration. When a sequence of instructions is executed in a repeated manner, it is called a loop.\"\n",
    "Source: https://www.techopedia.com/definition/3821/iteration\n",
    "\n",
    "#### When we iterate over something....\n",
    "We are performing a specific task a specific number of times based on the \"iterator\".\n",
    "\n",
    "\n",
    "<hr>\n",
    "\n",
    "## `Element` by `Type` of `Iterator`\n",
    "\n",
    "* `Lists` - element is each **_value_**\n",
    "* `Dictionaries` - element is each **_key_**\n",
    "    * Use `<dictionary>.values()` as the `iterator` to get all the **_values_**\n",
    "    * Use `<dictionary>.key()` as the `iterator` to get all the **_keys_**\n",
    "    * Use `<dictionary>.items()` as the `iterator` to get all the keys and values as **_tuple pairs_**\n",
    "* `Sets` - element is each **_value_**\n",
    "* `Tuples` - element is each **_value_**\n",
    "\n",
    "<hr>\n",
    "\n",
    "**SPECIAL**  \n",
    "You can use the function **_enumerate_** with your iterator to return both the _index_ and the original value.\n",
    "```python\n",
    "for (ind, <element>) in enumerate(<iterable>):\n",
    "    # do something!\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3]\n",
    "my_dictionary = {'one': 1, 'two': 2, 'three': 3}\n",
    "my_tuple = (4, 5, 6)\n",
    "my_set = {2, 3, 5, 7}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in my_list:\n",
    "    print('List value: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in my_tuple:\n",
    "    print('Tuple value: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in my_set:\n",
    "    print('Set value: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in my_dictionary:\n",
    "    print('Dictionary key: ', key)\n",
    "    \n",
    "print()\n",
    "    \n",
    "for key in my_dictionary.keys():\n",
    "    print('Dictionary key: ', key)\n",
    "    \n",
    "print()\n",
    "    \n",
    "for value in my_dictionary.values():\n",
    "    print('Dictionary value: ', value)\n",
    "    \n",
    "print()\n",
    "    \n",
    "for (key, value) in my_dictionary.items():\n",
    "    print('Dictionary key/value: ', key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for (ind, value) in enumerate(my_set):\n",
    "    print('Set index/value with enumerate: ', ind, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "### YOUR TURN\n",
    "\n",
    "**Create a dictionary of 5 words (keys) and their definitions (values).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_definitions = dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add several more words and their definitions**\n",
    "Example: \n",
    "```python\n",
    "word_definitions[\"Awesome\"] = \"The feeling of students when they are learning Python\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Use square bracket lookup to get the definition of two words and output them to the console with `print()`**\n",
    "\n",
    "If `Awesome` is a key in your `word_definitions`, you could then write: \n",
    "\n",
    "```python\n",
    "print(word_definitions['Awesome'])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over the dictionary to get the following output:**\n",
    "```\n",
    "The definition of [WORD] is [DEFINITION]\n",
    "The definition of [WORD] is [DEFINITION]\n",
    "The definition of [WORD] is [DEFINITION]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN.. AGAIN!\n",
    "\n",
    "Remember this??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'FooBar'\n",
    "\n",
    "if name == 'Foo':\n",
    "    print('First condition met')\n",
    "\n",
    "elif name == 'Bar':\n",
    "    print('Second condition met')\n",
    "\n",
    "else:\n",
    "    print('No idea what the name could be!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* For each prime number..\n",
    "* If.. the number is even, print `Prime [NUMBER] is even!`\n",
    "* Else if.. the number is less than 10, print `Prime [NUMBER] less than 10!`\n",
    "* Else if.. the number is less than 50, print `Prime [NUMBER] less than 50!`\n",
    "* Else.. print `Prime [NUMBER] is really big!`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## While Loops\n",
    "\n",
    "This is python's way of saying: \n",
    "> While a condition is met.. Do something.\n",
    "\n",
    "### General Syntax\n",
    "```python\n",
    "while <condition>:\n",
    "    # do something!\n",
    "```\n",
    "\n",
    "A really easy way to lock up your computer is to run this code:\n",
    "```python\n",
    "while True:\n",
    "    print(\"I'm a real data analyst!\")\n",
    "```\n",
    "\n",
    "Why does it break my computer, you ask? \n",
    "**_There is nothing stopping the condition from being True_**.\n",
    "\n",
    "In a `while loop`, you need to have a criteria that triggers a break. \n",
    "You need to make sure your condition has the ability to become `False`.\n",
    "\n",
    "Try running the code below as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = 1\n",
    "\n",
    "while index < 10:\n",
    "    print(f'{index} is less than 10!')\n",
    "    \n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Breaking it down\n",
    "\n",
    "What is our condition??\n",
    "```index < 10```\n",
    "\n",
    "Ok.. What is our _control??_\n",
    "In other words, how are we breaking our condition?\n",
    "\n",
    "```python\n",
    "index = 1\n",
    "...\n",
    "index += 1\n",
    "```\n",
    "\n",
    "Every iteration through our loop, we add 1 to our index. \n",
    "Since our condition becomes False when the index is 10 or above, our while loop will stop at 10.\n",
    "\n",
    "### Escaping the loop\n",
    "When creating a `while loop`, it is **_ALWAYS_** important to manage your _control_ so that you can escape the loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### YOUR TURN\n",
    "\n",
    "**Write a while loop that prints out `Prime [NUMBER] is less than 50` for all prime numbers that are less than 50!**"
   ]
  },
  {
   "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
}