notes/J2-Iteration-For_loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iteration: For Loops\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We discussed the while loop, and learned some basic strategies for writing code with loops. \n",
    "\n",
    "We now move on to discuss the `for` loop, a common way of iterating over complex data structures, (e.g., lists, set, dictionaries, etc.) that we examined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the for statement allows us to write programs that implement iteration. \n",
    "\n",
    "As a simple example, let’s say we have the names of the students in the class, and we want to send them a notification that\n",
    "we posted an assignment online and that the deadline is in a week. \n",
    "\n",
    "We do not want to write manually repeat the process of writing an email separately for each student, so we use a loop for that:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Joe\", \"Amy\", \"Brad\", \"Maria\", \"Sophia\", \"Michael\"]\n",
    "for name in students:\n",
    "    print(\"Hi\", name)\n",
    "    print(\"The assignment is now posted online.\")\n",
    "    print(\"The deadline is in one week.\")\n",
    "    print(\"Cheers,\\nPanos\")\n",
    "    print(\"------\")\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's examine the structure of the loop:\n",
    "\n",
    "* The `name` variable is called the loop variable or iteration variable. \n",
    "* The `name` variable changes in each iteration of the loop. It will iteratively take the value of each of the six values in the `students` list.\n",
    "* On each iteration of the loop, Python checks to see if there are still more items to be processed. If there are none left (this is called the terminating condition of the loop), the loop is finished and program execution continues at the next statement after the loop body.\n",
    "* If there are items still to be processed, the loop variable is updated to refer to the next item in the list. This means, in this case, that the loop body is executed here 6 times, and each time `name` will refer to a different student.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flowchart description of a for statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a more formal way, the flowchart below illustrates the execution order and logic in a `for` statement:\n",
    "\n",
    "\n",
    "![Flowchart for a for loop (from \"How to Think Like a Computer Scientist\")](http://interactivepython.org/runestone/static/thinkcspy/_images/new_flowchart_for.png)\n",
    "\n",
    "\n",
    "It is very important to grasp the concept of the **loop variable**, and understand that it will iteratively take the value of all the elements in the list. In fact, it is not necessary to iterate over a list. We can also iterate over sets, dictionaries, and other composite data structures. Let's see some examples next.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Write a program that uses a for loop to print\n",
    "\n",
    "* `One of the months of the year is January`\n",
    "* `One of the months of the year is February`\n",
    "* `One of the months of the year is March`\n",
    "* etc ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = [\n",
    "    \"January\",\n",
    "    \"February\",\n",
    "    \"March\",\n",
    "    \"April\",\n",
    "    \"May\",\n",
    "    \"June\",\n",
    "    \"July\",\n",
    "    \"August\",\n",
    "    \"September\",\n",
    "    \"October\",\n",
    "    \"November\",\n",
    "    \"December\",\n",
    "]\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": false
   },
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "months = [\n",
    "    \"January\",\n",
    "    \"February\",\n",
    "    \"March\",\n",
    "    \"April\",\n",
    "    \"May\",\n",
    "    \"June\",\n",
    "    \"July\",\n",
    "    \"August\",\n",
    "    \"September\",\n",
    "    \"October\",\n",
    "    \"November\",\n",
    "    \"December\",\n",
    "]\n",
    "\n",
    "for month in months:\n",
    "    print(\"One of the months of the year is\", month)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume you have a list of numbers `12, 10, 32, 3, 66, 17, 42, 99, 20`\n",
    "\n",
    "* Write a loop that prints each of the numbers on a new line.\n",
    "* Write a loop that prints each number and its square on a new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [12, 10, 32, 3, 66, 17, 42, 99, 20]\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Write a loop that prints each of the numbers on a new line.\n",
    "numbers = [12, 10, 32, 3, 66, 17, 42, 99, 20]\n",
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Write a loop that prints each number and its square on a new line.\n",
    "numbers = [12, 10, 32, 3, 66, 17, 42, 99, 20]\n",
    "for number in numbers:\n",
    "    print(number, \"==>\", number * number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ranges of Integers\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is convenient to define (and iterate through) ranges of integers. Python has a convenient `range` function that allows you to do just this. The `range` function allow us to generate a list of numbers:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(10)))  # start at zero, < the specified ceiling value\n",
    "\n",
    "for i in range(10):\n",
    "    print(i, \"squared is\", i * i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When range command has two parameters, it starts from the first parameter and finishes at the second \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from the left value, < right value\n",
    "print(list(range(-5, 5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range(10) is the same at range(0,10)\n",
    "print(list(range(10)))\n",
    "print(list(range(0, 10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When range has a third argument, this is the \"step\" value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from the left value, to the middle value, incrementing by the right value\n",
    "print(list(range(-5, 50, 5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Warning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps some of you, already familiar with programming, will tend to write code like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Old style, using indexing for loops\n",
    "names = [\"Abe\", \"Bill\", \"Chris\", \"Dorothy\", \"Ellis\"]\n",
    "for i in range(0, len(names)):\n",
    "    print(names[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "instead of\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pythonic style, use iterators\n",
    "names = [\"Abe\", \"Bill\", \"Chris\", \"Dorothy\", \"Ellis\"]\n",
    "for n in names:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avoid using the indexing style method for iterating through data structures. While technically both generate the same result, the \"Pythonic\" way of doing things is the latter: It is simpler, more readable, and less prone to errors.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "* print your name 10 times (easy, peasy). \n",
    "* print on the screen a \"triangle\", by printing first \"#\", then \"##\", then \"###\", etc. Repeat 10 times; _Hint: The command `print(i*'#')` will print the character '#' a total of `i` times._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "##\n",
    "###\n",
    "####\n",
    "#####\n",
    "######\n",
    "#######\n",
    "########\n",
    "#########\n",
    "##########"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Notice that the loop variable \"i\"\n",
    "# is not used within the loop\n",
    "for i in range(10):\n",
    "    print(\"Panos!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Sometimes, when the loop variable is not\n",
    "# used within the loop, the convention is to use\n",
    "# underscore _ as the variable name. (Yes, it is a valid variable name)\n",
    "for _ in range(10):\n",
    "    print(\"Panos!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i * \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print((i + 1) * \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for i in range(1, 11):\n",
    "    print(i * \"#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating through lists, sets, and dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` statements are a convenient way to iterate through the values contained in a data structure. \n",
    "\n",
    "Let's see now examples for iterating over lists, sets, and dictionaries. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating through lists\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already gone through some simple examples, so let's work on a bit more elaborate example. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a list with the names of the NBA teams. We want to process all of them, and extract the \"franchise\" name (e.g., `Knicks` is the franchise name for NY Knicks). For all (current) NBA teams, the franchise name is the last part of the team name. Let's see how we can do that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nba_teams = [\n",
    "    \"Atlanta Hawks\",\n",
    "    \"Boston Celtics\",\n",
    "    \"Brooklyn Nets\",\n",
    "    \"Charlotte Hornets\",\n",
    "    \"Chicago Bulls\",\n",
    "    \"Cleveland Cavaliers\",\n",
    "    \"Dallas Mavericks\",\n",
    "    \"Denver Nuggets\",\n",
    "    \"Detroit Pistons\",\n",
    "    \"Golden State Warriors\",\n",
    "    \"Houston Rockets\",\n",
    "    \"Indiana Pacers\",\n",
    "    \"LA Clippers\",\n",
    "    \"Los Angeles Lakers\",\n",
    "    \"Memphis Grizzlies\",\n",
    "    \"Miami Heat\",\n",
    "    \"Milwaukee Bucks\",\n",
    "    \"Minnesota Timberwolves\",\n",
    "    \"New Orleans Pelicans\",\n",
    "    \"New York Knicks\",\n",
    "    \"Oklahoma City Thunder\",\n",
    "    \"Orlando Magic\",\n",
    "    \"Philadelphia 76ers\",\n",
    "    \"Phoenix Suns\",\n",
    "    \"Portland Trail Blazers\",\n",
    "    \"Sacramento Kings\",\n",
    "    \"San Antonio Spurs\",\n",
    "    \"Toronto Raptors\",\n",
    "    \"Utah Jazz\",\n",
    "    \"Washington Wizards\",\n",
    "]\n",
    "print(\"The list contains\", len(nba_teams), \"teams\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see an example of processing a single team name to get the franchise name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "team = \"Atlanta Hawks\"\n",
    "team_words = team.split()\n",
    "print(team_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "franchise = team_words[-1]\n",
    "print(franchise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we should use -1 as the index to get the _last_ word, and **not** try to get the _second_ word, as this would not work with team names such as \"New York Knicks\" or \"Los Angeles Lakers\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "team = \"Los Angeles Lakers\"\n",
    "team_words = team.split()\n",
    "franchise = team_words[-1]\n",
    "print(team_words)\n",
    "print(franchise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, now we take the code for extracting the franchise name, and put it within the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for team in nba_teams:\n",
    "    franchise = team.split()[-1]\n",
    "    print(team, \"\\t ==>\\t\", franchise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating over sets and tuples\n",
    "\n",
    "The process of iterating through sets and tuples is pretty much identical to the one for lists. Let's see a few examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterating over a set\n",
    "print(\"Print all numbers in the set, and their square\")\n",
    "set_a = {1, 2, 3, 4, 5, 6}\n",
    "for i in set_a:\n",
    "    print(i, \" squared is:\", i * i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"A more complex block: Only print squares of even numbers\")\n",
    "set_a = {1, 2, 3, 4, 5, 6}\n",
    "for i in set_a:\n",
    "    # print(i)\n",
    "    if i % 2 == 0:\n",
    "        print(\"==> \", i, \" squared is:\", i * i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterating over a tuple\n",
    "print(\"Print all numbers in the tuple, and their square\")\n",
    "tuple_a = (1, 2, 3, 4, 5, 6)\n",
    "for i in tuple_a:\n",
    "    print(i, \" squared is:\", i * i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating over dictionaries\n",
    "\n",
    "Iterating through dictionaries is a bit more complex. You can iterate through keys, values, or both.  \n",
    "\n",
    "Here is an dictionary, which we will use as an example. It contains names as keys, and phone numbers as corresponding values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phones = {\n",
    "    \"Panos\": \"212-998-0803\",\n",
    "    \"Maria\": \"656-233-5555\",\n",
    "    \"John\": \"693-232-5776\",\n",
    "    \"Jake\": \"415-794-3423\",\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterating over keys\n",
    "\n",
    "By default, when we iterate over a dictionary, we are iterating over the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Iterating over keys\")\n",
    "for k in phones:\n",
    "    print(\"key =\", k, \", value =\", phones[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Iterating over keys, more explicit\")\n",
    "for k in phones.keys():\n",
    "    print(\"key =\", k, \", value =\", phones[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to print the keys in alphabetical order, you first make a list of the keys in the dictionary using the keys method available in dictionary objects, and then sort that list and loop through the sorted list, looking up each key and printing out key-value pairs in sorted order as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Iterating over sorted keys\")\n",
    "sorted_keys = sorted(phones.keys())\n",
    "for k in sorted_keys:\n",
    "    print(\"key =\", k, \", value =\", phones[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterating over values\n",
    "\n",
    "It is also possible to iterate over the values for the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Iterating over values\")\n",
    "for v in phones.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterating over key-value pairs\n",
    "\n",
    "Notice that when we iterate over the keys of a dictionary, we tend to use the `phones[k]` structure to get the value associated with the key `k`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Iterating over both keys and values\")\n",
    "# Items returns *tuples* that correspond to key-value pairs\n",
    "# (\"Panos\", \"212-998-0803\"), (\"Maria\": \"656-233-5555\"), etc.\n",
    "\n",
    "# Notice that we have a *tuple* (k,v) now as a loop variable, and the tuple\n",
    "# has two entries, the key k  and the value v\n",
    "for (k, v) in phones.items():\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rewriting, with a bit more descriptive variable names\n",
    "for (name, phone) in phones.items():\n",
    "    print(\"Name:\", name, \"Phone:\", phone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you are confused with the (k,v) being the loop variable\n",
    "# you can see the same loop where the loop variable is \"item\"\n",
    "# Then we access the two elements of the tuple within the body\n",
    "# of the loop name = item[0] and phone = item[1]\n",
    "for item in phones.items():\n",
    "    name = item[0]\n",
    "    phone = item[1]\n",
    "    print(\"Name:\", name, \"Phone:\", phone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's work on an exercise now, showing how we can iterate through a nested data structure.\n",
    "\n",
    "You are given the composite data structure below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    \"Foster\": {\n",
    "        \"Job\": \"Professor\",\n",
    "        \"YOB\": 1965,\n",
    "        \"Children\": [\"Hannah\"],\n",
    "        \"Awards\": [\"Best Teacher 2014\", \"Best Researcher 2015\"],\n",
    "        \"Salary\": 120000,\n",
    "    },\n",
    "    \"Joe\": {\"Job\": \"Data Scientist\", \"YOB\": 1981, \"Salary\": 200000},\n",
    "    \"Maria\": {\n",
    "        \"Job\": \"Software Engineer\",\n",
    "        \"YOB\": 1993,\n",
    "        \"Children\": [],\n",
    "        \"Awards\": [\n",
    "            \"Dean's List 2013\",\n",
    "            \"Valedictorian 2011\",\n",
    "            \"First place in Math Olympiad 2010\",\n",
    "        ],\n",
    "    },\n",
    "    \"Panos\": {\"Job\": \"Professor\", \"YOB\": 1976, \"Children\": [\"Gregory\", \"Anna\"]},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1:\n",
    "\n",
    "* Print the names of the people from the dictionary below, by iterating through the keys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Print the names of people in the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for name in data:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for name in data.keys():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2:\n",
    "\n",
    "* Print the age of each person, by iterating through the keys, and then looking up the \"YOB\" entry.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Print the names and age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for name in data.keys():\n",
    "    yob = data[name][\"YOB\"]\n",
    "    age = 2018 - yob\n",
    "    print(\"Name:\", name, \"\\t\", \"Age:\", age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Alternatively, using the data.items() approach\n",
    "for name, entry in data.items():\n",
    "    yob = entry[\"YOB\"]  # instead of data[name], we use entry\n",
    "    age = 2018 - yob\n",
    "    print(\"Name:\", name, \"\\t\", \"Age:\", age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3:\n",
    "\n",
    "* Print the names of people born after 1980"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Print the names of people born after 1980"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for name in data.keys():\n",
    "    yob = data[name][\"YOB\"]\n",
    "    if yob > 1980:\n",
    "        print(\"Name:\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4:\n",
    "\n",
    "* Print the number of children for each person. You need to check if the \"Children\" list exists in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Print the number of children for each perspon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for name in data.keys():\n",
    "    # Get the value associated with the name (name = loop variable)\n",
    "    # The 'entry' variable is the value the key 'name'\n",
    "    # In our case, this is a dictionary with entries 'Job', 'YOB', etc\n",
    "    entry = data[name]\n",
    "\n",
    "    # If we do not check if 'Children' appears in entry, then we will get\n",
    "    # an error for 'Joe', whose dictionary does not have a 'Children' key\n",
    "    if \"Children\" in entry.keys():\n",
    "        num_children = len(entry[\"Children\"])\n",
    "    else:\n",
    "        num_children = 0\n",
    "    print(\"Name:\", name, \"\\t\", \"Children:\", num_children)"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}