filled_Introduction_to_Programming_with_Python_2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "tthj14biQ8PC"
   },
   "source": [
    "# Introduction to Programming with Python - Part 2\n",
    "\n",
    "## 1.&nbsp;Introduction and Setup\n",
    "\n",
    "With this Google Colaboratory (Colab) notebook open, **click the \"Copy to Drive\" button that appears in the menu bar**. The notebook will then be attached to your own user account, so you can edit it in any way you like -- you can even take notes directly in the notebook.\n",
    "\n",
    "### Learning objectives\n",
    "\n",
    "By the end of our workshop today, we hope you'll build on basic Python syntax to understand control flow, inlcuding for loops and if statements. With these in hand, you'll know enough to write and apply basic scripts and explore other features of the language.\n",
    "\n",
    "### Today's Topics\n",
    "- Comparison operators\n",
    "- If statements\n",
    "- For loops\n",
    "\n",
    "We will continue these topics in our next workshop!\n",
    "\n",
    "For a reference to previous workshop content, you can access a version of the previous workshop materials with all example and exercise code completed in the [Introduction to Programming with Python - Part 1 filled notebook](https://colab.research.google.com/github/ncsu-libraries-data-vis/introduction-to-programming-with-python/blob/main/filled_Introduction_to_Programming_with_Python_1.ipynb)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EltGLYRoGIwN"
   },
   "source": [
    "### Questions during the workshop\n",
    "\n",
    "Please feel free to ask questions throughout the workshop.\n",
    "\n",
    "We have a second instructor who will available during the workshop. They will answer as able, and will collect questions with answers that might help everyone to be answered at the end of the workshop."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EXNouJI__sf2"
   },
   "source": [
    "### Jupyter Notebooks and Google Colaboratory\n",
    "\n",
    "We will be using Google Colab in today's workshop. Jupyter notebooks are a way to write and run Python code in an interactive way. If you would like to know more about Colaboratory or how to use this tool, you can visit the [Welcome Notebook](https://colab.research.google.com/notebooks/welcome.ipynb).\n",
    "\n",
    "If you'd like to install a Python distribution locally, though, we're happy to help. Feel free to [get help from our graduate consultants](https://go.ncsu.edu/getdatahelp) or [schedule an appointment with Libraries staff](https://go.ncsu.edu/dvs-request)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Lk20eiVAHIwv"
   },
   "source": [
    "## Control flow \n",
    "\n",
    "Control flow refers to statements that allow you to change the path of your program. Instead of executing each line of code in order sequentially, control flow allows you to skip lines of code, to move to different lines of code, or to repeatedly execute lines of code.\n",
    "\n",
    "To learn more about control flow:\n",
    "\n",
    "- [\"Control Flow\" chapter of *A Byte of Python*](https://python.swaroopch.com/control_flow.html)\n",
    "- [Python documentation on control flow tools](https://docs.python.org/3/tutorial/controlflow.html)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "wtHp5Yf9o5mc"
   },
   "source": [
    "### Comparison Operators\n",
    "\n",
    "Comparison operators are used to compare two values and return a value of `True` or `False`, a boolean data type. They are often used in if statements.\n",
    "\n",
    "The following are Python comparison operators: `==`, `!=`, `>`, `<`, `>=`, `<=`\n",
    "\n",
    "*Note:* To compare two values, make sure to use `==`. A single `=` is used for assignment, like creating variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 454,
     "status": "ok",
     "timestamp": 1614190269667,
     "user": {
      "displayName": "Ashley Evans Bandy",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiEnggm2Xb6QnXpmQaXw4S5OovXByctlJmtN-OizA=s64",
      "userId": "14475997041039881783"
     },
     "user_tz": 300
    },
    "id": "ZVaOVYZwY_GJ",
    "outputId": "a0392bb4-4888-44b2-9b17-257c60f2d226"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare numbers\n",
    "5 > 2\n",
    "5 == 2\n",
    "5 != 2\n",
    "5 >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dbjij2HOZGYO",
    "outputId": "d1e14040-7e5e-4058-bbc0-3e67d8a6f9d0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare strings\n",
    "\"This string\" == \"This string\"\n",
    "\"This string\" == \"this string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RcTJdQUpSmgY",
    "outputId": "ccdf7d86-df30-4c6e-f448-16b9577e751b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare other expressions using multiple data types\n",
    "len(\"cat\") > 5 - 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "TIZ1-awbzbRF"
   },
   "source": [
    "**Try it yourself:** What is the result of this comparison?\n",
    "\n",
    "*Hint:* Remember that lists are surrounded by square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "aT-bNlRwz7vG"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1, 2]) == 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operators\n",
    "\n",
    "Logical operators are used to evaluate multiple conditional statements and return a value of `True` or `False`, a boolean data type. They allow us to combine the results of multiple comparisons.\n",
    "\n",
    "The following are Python comparison operators: `and`, `or`, `not`\n",
    "\n",
    "- `and` checks if both conditions are true\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/ncsu-libraries-data-vis/introduction-to-programming-with-python/main/images/venn_diagram_and.png\" alt=\"A venn diagram labeled 'and' with the middle, overlapping section shaded in. Shows that 'and' is true only when both conditions are met.\" width=\"25%\"/>\n",
    "\n",
    "- `or` for at least one condition to be true\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/ncsu-libraries-data-vis/introduction-to-programming-with-python/main/images/venn_diagram_or.png\" alt=\"A venn diagram labeled 'or,' with both circles completely filled in. Shows that 'or' is true if either of the two conditions are met or both conditions are met.\" width=\"25%\"/>\n",
    "\n",
    "- `not` checks for the opposite of the condition\n",
    "\n",
    "To learn more about logical and comparison operators:\n",
    "\n",
    "-  [\"Operators and Expressions\"](https://python.swaroopch.com/op_exp.html) chapter in a *Byte of Python*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a variable to use in the following examples\n",
    "num = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The \"and\" operator checks if both conditions are True\n",
    "num > 3 and num < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The \"or\" operator checks if at least one of the conditions are True\n",
    "num > 3 or num < -3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The \"not\" operator returns the opposite of the return of a comparison\n",
    "not num > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using multiple logical operators, order of evaluation goes from \"not\" to\n",
    "# \"and\" to \"or\". Logical expressions surrounded by parentheses will be\n",
    "# evaluated first\n",
    "\n",
    "# Results without parentheses\n",
    "print(type(num) == int and not num == 0 or num == 5)\n",
    "\n",
    "# Results with parentheses\n",
    "type(num) == int and not (num == 0 or num == 5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try it Yourself:** Write a statement that checks if a number is less than 10 and greater than zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a variable with a number in it\n",
    "example_num = 4\n",
    "\n",
    "# is the number greater than 0 and also less than 10?\n",
    "example_num > 0 and example_num < 10"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bonus Try it Yourself:** Write a statement that checks if an integer is even (divisible by 2) and is either greater than 10 or less than -10.\n",
    "\n",
    "*Hint: Check out the [Python modulo operator (%)](https://realpython.com/python-modulo-operator/#modulo-operator-with-int) for testing if an integer is divisible by 2. Also, remember order of logical operator evaluation*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a variable with a number in it\n",
    "example_num = -26\n",
    "\n",
    "# \"%\"\" returns the remainder after division. If a number is even and divided by\n",
    "# 2, the remainder should be 0\n",
    "example_num % 2 == 0 and (example_num < -10 or example_num > 10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "v-LYg5HFTqqS"
   },
   "source": [
    "### If Statements\n",
    "\n",
    "\"The if statement is used to check a condition: if the condition is true, we run a block of statements (called the if-block), else we process another block of statements (called the else-block). The else clause is optional.\" (From [\"Control Flow\" chapter of *A Byte of Python* includes a section on \"If Statements\"](https://python.swaroopch.com/control_flow.html))\n",
    "\n",
    "A block of code associated with an if statement is defined using indentation. A basic if statement has the following generalized syntax:\n",
    "\n",
    "```python\n",
    "if conditional_expression:\n",
    "    '''\n",
    "    indented block of code\n",
    "    that will run when\n",
    "    conditional_expression equals true\n",
    "    '''\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "KISb4TEqjZ7b"
   },
   "source": [
    "#### If, Else (`if`, `else`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EDJp21NoHIwv",
    "outputId": "ae92d0ac-34ca-4181-9810-22c50600a796"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Bill!\n"
     ]
    }
   ],
   "source": [
    "# If statements (conditional execution)\n",
    "cat_name = \"Bill\"\n",
    "\n",
    "# Print \"Hi Bill!\" if cat_name is \"Bill\"\n",
    "# Add an else statement if the condition isn't met\n",
    "if cat_name == \"Bill\":\n",
    "    print(\"Hi Bill!\")\n",
    "else:\n",
    "    print(\"Who are you?\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If, Else if, Else (`if`, `elif`, `else`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NdAGrsNTHIwz",
    "outputId": "9979185f-a13b-4c01-8e96-32e6eacf4766"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Sally!\n"
     ]
    }
   ],
   "source": [
    "# You can use if, else if (\"elif\"), and else to specify more than one condition\n",
    "cat_name = \"Sally\"\n",
    "\n",
    "# Print \"Hi Bill!\" if cat_name is \"Bill\"\n",
    "# Print \"Hi Sally!\" if cat_name is \"Sally\"\n",
    "# Add an else statement if the condition isn't met\n",
    "if cat_name == \"Bill\":\n",
    "    print(\"Hi Bill!\")\n",
    "elif cat_name == \"Sally\":\n",
    "    print(\"Hi Sally!\")\n",
    "else:\n",
    "    print(\"Who are you?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oM5eWA7bmdl5",
    "outputId": "65314e08-028a-4186-ed22-dfbf0702febd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Bill!\n"
     ]
    }
   ],
   "source": [
    "# You can also add logical operators (and, or, not) to evaluate expressions.\n",
    "cat_name = \"Bill\"\n",
    "\n",
    "# Print \"Hi Bill!\" if cat_name is \"Bill\"\n",
    "# Print \"Hi Sally!\" if cat_name is \"Sally\"\n",
    "# Add an else statement if the condition isn't met\n",
    "if cat_name == \"Sally\" or cat_name == \"Bill\":\n",
    "    print(\"Hi \" + cat_name + \"!\")\n",
    "else:\n",
    "    print(\"Who are you?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tsekt_Q0sK28",
    "outputId": "39ff0aeb-64e0-4f27-f2de-c10a2fe529ec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are a kitten, Bill\n"
     ]
    }
   ],
   "source": [
    "# Comparing numbers in an if statement \n",
    "cat_ages = {\n",
    "    \"Sally\": 5, \n",
    "    \"Bob\": 16,\n",
    "    \"Bill\": 1,\n",
    "    \"Carla\": 10,\n",
    "    \"Pete\": 3\n",
    "}\n",
    "\n",
    "cat_name = \"Bill\"\n",
    "\n",
    "# Print a message based on the age range of a cat\n",
    "# 0 to 3 years old = kitten\n",
    "# 3 to 10 years old = adult\n",
    "# 10 or more years old = senior\n",
    "if cat_ages[cat_name] < 3:\n",
    "    print(\"You are a kitten, \" + cat_name)\n",
    "elif cat_ages[cat_name] >= 3 and cat_ages[cat_name] < 10:\n",
    "    print(\"You are an adult, \" + cat_name)\n",
    "else:\n",
    "    print(\"You are a senior cat, \" + cat_name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, you can use the logical comparisons `in` and `not in` to evaluate if a value is or is not in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my cat!\n"
     ]
    }
   ],
   "source": [
    "# A list of my cats\n",
    "my_cats = [\"Bill\", \"Bob\"]\n",
    "\n",
    "cat_name = \"Bill\"\n",
    "\n",
    "# Print \"This is my cat!\" if a name is in \"my_cats\"\n",
    "if cat_name in my_cats:\n",
    "    print (\"This is my cat!\")\n",
    "else:\n",
    "    print (\"This is not my cat.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try it yourself:** Write an if statement that prints out a message based on membership in the *International Cats of Mystery* service. Two lists are provided below, one for current members and one for new members.\n",
    "\n",
    "Members will see, _\"Thank you for being a member!\"_\n",
    "\n",
    "New members will see, _\"Welcome to the International Cats of Mystery!\"_\n",
    "\n",
    "Anyone else will be asked, _\"Would you like to join the International Cats of Mystery?\"_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thank you for being a member!\n"
     ]
    }
   ],
   "source": [
    "# Current members\n",
    "members = [\"Pete\", \"Carla\", \"Bob\"]\n",
    "# New members\n",
    "new_members = [\"Bill\"]\n",
    "\n",
    "# A name to test\n",
    "name_test = \"Carla\"\n",
    "\n",
    "# Write an if statement here\n",
    "if name_test in new_members:\n",
    "    print(\"Welcome to the International Cats of Mystery!\")\n",
    "elif name_test in members: \n",
    "    print(\"Thank you for being a member!\")\n",
    "else:\n",
    "    print(\"Would you like to join the International Cats of Mystery?\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Ay8ASNZ5Dhga"
   },
   "source": [
    "## Five (5) Minute Break"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Budxyg0zT4eK"
   },
   "source": [
    "### For loops\n",
    "\n",
    "For loops iterate over a sequence of objects and allow us to run a block of code for each object in the sequence.\n",
    "\n",
    "For example, a \"For loop\" can be used to go through a list of names, and evaluate whether each name is uppercase or not.\n",
    "\n",
    "Like if statements, a block of code associated with a for loop is defined using indentation. A for loop has the generalized syntax:\n",
    "\n",
    "```python\n",
    "for item in sequence:\n",
    "    '''\n",
    "    indented block of code\n",
    "    that will run for each\n",
    "    item in sequence\n",
    "    '''\n",
    "```\n",
    "\n",
    "- [Refer to the \"For loop\" section in \"Control Flow\" chapter of *A Byte of Python*](https://python.swaroopch.com/functions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D0rVgXIxn8XS",
    "outputId": "e57b6f34-0a92-4ab0-827b-ae4e37db218d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Iterate over a range using the \"range()\" function\n",
    "# The range function returns a sequence of numbers\n",
    "for i in range(6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zXdkrbOFtOJo",
    "outputId": "e053a9c6-c70b-4be4-96d8-b56417db5e85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "i\n",
      "l\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "# Iterate over a string\n",
    "for letter in \"Bill\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "quma-JNWHIw3",
    "outputId": "751daf19-a5a2-4736-8cfd-0cc946eefc5e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob 3\n",
      "Bill 4\n",
      "Pete 4\n",
      "Carla 5\n",
      "Sally 5\n"
     ]
    }
   ],
   "source": [
    "# For loops let you iterate over a list\n",
    "cat_names = [\"Bob\", \"Bill\", \"Pete\", \"Carla\", \"Sally\"]\n",
    "\n",
    "# Loop over the members of cat_names to print out the element and its length\n",
    "for name in cat_names:\n",
    "    print(name, len(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key: Sally\n",
      "key: Bob\n",
      "key: Bill\n",
      "key: Carla\n",
      "key: Pete\n",
      "key: Sally\n",
      "key: Bob\n",
      "key: Bill\n",
      "key: Carla\n",
      "key: Pete\n",
      "value: 5\n",
      "value: 16\n",
      "value: 1\n",
      "value: 10\n",
      "value: 3\n",
      "value: 5\n",
      "value: 16\n",
      "value: 1\n",
      "value: 10\n",
      "value: 3\n",
      "key: Sally, value: 5\n",
      "key: Bob, value: 16\n",
      "key: Bill, value: 1\n",
      "key: Carla, value: 10\n",
      "key: Pete, value: 3\n",
      "key: Sally, value: 5\n",
      "key: Bob, value: 16\n",
      "key: Bill, value: 1\n",
      "key: Carla, value: 10\n",
      "key: Pete, value: 3\n"
     ]
    }
   ],
   "source": [
    "# There are a few ways to iterate over a dictionary, depending on the part of\n",
    "# the dictionary you need\n",
    "cat_ages = {\n",
    "    \"Sally\": 5, \n",
    "    \"Bob\": 16,\n",
    "    \"Bill\": 1,\n",
    "    \"Carla\": 10,\n",
    "    \"Pete\": 3\n",
    "}\n",
    "\n",
    "# Iterate using a dictionary's keys\n",
    "# See also dict.keys()\n",
    "for cat in cat_ages:\n",
    "    print(\"key:\", cat)\n",
    "\n",
    "for cat in cat_ages.keys():\n",
    "    print(\"key:\", cat)\n",
    "\n",
    "# Iterate using a dictionary's keys to get the values\n",
    "# See also dict.values()\n",
    "for cat in cat_ages:\n",
    "    print(\"value:\", cat_ages[cat])\n",
    "\n",
    "for age in cat_ages.values():\n",
    "    print(\"value:\", age)\n",
    "\n",
    "# Iterate using a dictionary's keys and values\n",
    "# See also dict.items()\n",
    "for cat in cat_ages:\n",
    "    print(f\"key: {cat}, value: {cat_ages[cat]}\")\n",
    "\n",
    "for cat, age in cat_ages.items():\n",
    "    print(f\"key: {cat}, value: {age}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oMXUE6vQHIw5",
    "outputId": "f2ab818d-1b41-41c4-e1fd-f5d57e1bee2d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bill\n",
      "Pete\n",
      "Carla\n",
      "Sally\n"
     ]
    }
   ],
   "source": [
    "# You can combine types of control flow, this is called \"nesting\"\n",
    "for name in cat_names:\n",
    "    if len(name) > 3:\n",
    "        print(name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "aTFfhbLqT_fC"
   },
   "source": [
    "### List Comprehensions\n",
    "\n",
    "List comprehensions are a \"pythonic\" way of building lists in a compact manner. They do not operate differently from other for loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NY2cs8OyHIxA",
    "outputId": "1ecc8a8e-b294-48a9-928e-40abe128db79"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A list of numbers\n",
    "nums = [1, 2, 3, 4]\n",
    "\n",
    "# Create a new list by adding 1 to the values in nums\n",
    "[num + 1 for num in nums]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_pB53kxgHIxD",
    "outputId": "c05506b0-c0f1-41e3-89ce-da70fc2226be"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bill', 'pete', 'carla', 'sally']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using conditional statements in list comprehension\n",
    "\n",
    "# A list of cat names\n",
    "cat_names = [\"Bob\", \"Bill\", \"Pete\", \"Carla\", \"Sally\"]\n",
    "\n",
    "# Create a new list of lowercase cat_names that are longer than 3 characters\n",
    "[cat_name.lower() for cat_name in cat_names if len(cat_name) > 3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try it yourself:** Write a for loop that prints out the names that begin with the letter \"B\" in the list `cat_names`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob\n",
      "Bill\n"
     ]
    }
   ],
   "source": [
    "# A list of cat names\n",
    "cat_names = [\"Bob\", \"Bill\", \"Pete\", \"Carla\", \"Sally\"]\n",
    "\n",
    "for name in cat_names:\n",
    "    if name[0] == \"B\":\n",
    "        print(name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bonus Try it yourself:** Write a list comprehension that adds 10 points to each test grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[105, 72, 85, 90]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_grades = [95, 62, 75, 80]\n",
    "\n",
    "[grade + 10 for grade in test_grades]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final Activity\n",
    "\n",
    "This activity will use what we have learned so far to automate a common marketing administrative task that you have probably seen in your own email inbox, a personalized letter greeting and discount offer.\n",
    "\n",
    "The dataset below contains information on members of the *International Cats of Mystery* service. Each member's data is contained in a Python dictionary and includes:\n",
    "  1. the member's name\n",
    "  2. the date they joined the service\n",
    "  3. their address information\n",
    "  4. an ordered list of the subscriptions they have with the service (from most popular to least popular subscription).\n",
    "\n",
    "Write code that produces a personalized message for all four members. These are the groups and messages to print for each group:\n",
    "\n",
    "Members who joined the service this year:\n",
    "> *Welcome, **[member name]**!*\n",
    "\n",
    "Members who joined the service prior to the current year and have at least one subscription:\n",
    "> *We would like to offer you a discount on the **[member's top subscription with the service]**!*\n",
    "\n",
    "Members who joined the service prior to the current year and have no subscriptions:\n",
    "> *Thanks for being a member!*"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The dataset\n",
    "\n",
    "Each member's information is contained in a dictionary and stored in a variable. Don't forget to run the cell containing the dictionary!\n",
    "\n",
    "Tip: Remember that you can \"call,\" or \"pull,\" a value from a dictionary \n",
    "using the key (e.g., `dictionary[\"key\"]`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries containing individual member information for members of the\n",
    "# International Cats of Mystery service\n",
    "member_info_1 = {\"name\": \"Bill\", \n",
    "                 \"joined\": 2022, \n",
    "                 \"address 1\": \"12309 Scratch Tree Lane\", \n",
    "                 \"city\": \"Beverly Hills\", \n",
    "                 \"state\": \"CA\", \n",
    "                 \"subscriptions\" : ['Little Known Hiss-tories podcast']}\n",
    "member_info_2 = {\"name\": \"Pete\", \n",
    "                 \"joined\": 2018, \n",
    "                 \"address 1\": \"501 Grumpy Street\", \n",
    "                 \"city\": \"Long Beach\", \n",
    "                 \"state\": \"California\", \n",
    "                 \"subscriptions\" : ['Leisure Cats magazine','Little Known Hiss-tories podcast']}\n",
    "member_info_3 = {\"name\": \"Omar\", \n",
    "                 \"joined\": 2008, \n",
    "                 \"address 1\": \"9 Catnado Way\", \n",
    "                 \"city\": \"Bellevue\", \n",
    "                 \"state\": \"WA\", \n",
    "                 \"subscriptions\" : []}\n",
    "member_info_4 = {\"name\": \"Carla\", \n",
    "                 \"joined\": 2006, \n",
    "                 \"address 1\": \"2120 Curious Court\", \n",
    "                 \"city\": \"Raleigh\", \n",
    "                 \"state\": \"North Carolina\", \n",
    "                 \"subscriptions\" : ['email newsletter', 'Cat Nips subscription box']}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code that produces a personalized message for all four members. For reference, these are the groups and messages to print:\n",
    "\n",
    "Members who joined the service this year:\n",
    "> *Welcome, **[member name]**!*\n",
    "\n",
    "Members who joined the service prior to the current year and have at least one subscription:\n",
    "> *We would like to offer you a discount on the **[member's top subscription with the service]**!*\n",
    "\n",
    "Members  who joined the service prior to the current year and have no subscriptions:\n",
    "> *Thanks for being a member!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome, Bill!\n",
      "We would like to offer you a discount on the Leisure Cats magazine!\n",
      "Thank you for being a member!\n",
      "We would like to offer you a discount on the email newsletter!\n"
     ]
    }
   ],
   "source": [
    "# Create a list of each dictionary with member information\n",
    "members = [member_info_1, member_info_2, member_info_3, member_info_4]\n",
    "\n",
    "# Loop through each dictionary in the list\n",
    "for cat in members:\n",
    "    # If the member joined this year\n",
    "    if cat[\"joined\"] >= 2021:\n",
    "        print(\"Welcome, \" + cat[\"name\"] + \"!\") \n",
    "    # If the member joined prior to the current year and has at least one\n",
    "    # subscription\n",
    "    elif cat[\"joined\"] < 2021 and len(cat[\"subscriptions\"]) > 0:\n",
    "        print(\"We would like to offer you a discount on the \" \n",
    "              + cat[\"subscriptions\"][0] + \"!\")\n",
    "    # If the member joined prior to the current year but has no subscriptions\n",
    "    elif cat[\"joined\"] < 2021 and len(cat[\"subscriptions\"]) == 0:\n",
    "        print(\"Thank you for being a member!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "FgsqJZovHIxS"
   },
   "source": [
    "## Further resources and topics\n",
    "\n",
    "### Unfilled version of this notebook\n",
    "\n",
    "[Introduction to Programming with Python - Part 2 unfilled notebook](https://colab.research.google.com/github/ncsu-libraries-data-vis/introduction-to-programming-with-python/blob/main/Introduction_to_Programming_with_Python_2.ipynb) - a version of this notebook without code filled in for the guided activity and exercises. Use the unfilled version to learn these materials or lead a workshop session.\n",
    "\n",
    "### Introduction to Programming with Python - Part 3\n",
    "\n",
    "In the next workshop we will cover functions and reading and writing files.\n",
    "\n",
    "### Resources\n",
    "\n",
    "- [A Byte of Python](https://python.swaroopch.com/) is a great intro book and reference for Python\n",
    "- [Official Python documentation and tutorials](https://docs.python.org/3/)\n",
    "- [Real Python](https://realpython.com/) contains a lot of different tutorials at different levels\n",
    "- [LinkedIn Learning](https://www.lynda.com/Python-training-tutorials/415-0.html) is free with NC State accounts and contains several video series for learning Python\n",
    "- [Dataquest](https://www.dataquest.io/) is a free then paid series of courses with an emphasis on data science\n",
    "\n",
    "### Topics\n",
    "\n",
    "- Other data structures: sets, tuples\n",
    "- Libraries, packages, and pip\n",
    "- Virtual environments\n",
    "- Text editors and local execution environments\n",
    "- The object-oriented paradigm in Python: classes, methods\n",
    "\n",
    "### Installing Python \n",
    "\n",
    "There are quite a few ways to install Python on your own computer, including the [official Python downloads](https://www.python.org/downloads/) and the very popular data-science focused [Anaconda Python distribution](https://www.anaconda.com/products/individual). Depending on your operating system, how you want to write code, and what type of projects you might work on, there are other approaches as well, such as using [pyenv](https://github.com/pyenv/pyenv) and [poetry](https://python-poetry.org/). If you're not sure which approach to take, feel free to get in touch and we'll talk through options and help you get set up. \n",
    "\n",
    "### Popular editors for Python\n",
    "\n",
    "Today we've been writing and running code in Google Colab, which is one particular version of Jupyter Notebooks. Depending on your projects and what you're working on, you may want to write your code in a text editor. While there are many options, if you're just getting started we recommend [Visual Studio Code](https://code.visualstudio.com/) for any operating system but are happy to talk through other editors.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "YjyTIZsdGI0D"
   },
   "source": [
    "## Evaluation survey\n",
    "Please, spend 1 minute answering these questions that can help us a lot on future workshops. \n",
    "\n",
    "[go.ncsu.edu/dvs-eval](https://go.ncsu.edu/dvs-eval)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "y1yQcuLJGI0F"
   },
   "source": [
    "## Credits\n",
    "\n",
    "These materials were developed by Claire Cahoon and Walt Gurley from the NC State University Libraries. Materials are based on workshops by Scott Bailey, Ashley Evans Bandy, Natalia Lopez, Vincent Tompkins, Javier de la Rosa, Peter Broadwell, and Simon Wiles."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional Practice Activities"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "JzaZUzTEqrDj"
   },
   "source": [
    "### 1. Test for correct member state names using a `for` loop and `if` statements\n",
    "\n",
    "We have combined the individual membership information for each member of the *International Cats of Mystery* service into the list `members`. We need to determine if the `state` address listing for each member is formatted correctly as a two letter abbreviation (e.g., North Dakota should be listed as ND).\n",
    "\n",
    "Create a for loop to iterate over the list of members to test if each member's `state` address listing is formatted correctly as a two letter abbreviation. If it is correctly formatted, print out:\n",
    "\n",
    ">  State name correct for **[member name]**\n",
    "\n",
    "if it is not correctly formatted, print:\n",
    "\n",
    "> Fix **[member state]** for **[member name]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries containing individual member information for members of the\n",
    "# International Cats of Mystery service\n",
    "member_info_1 = {\"name\": \"Bill\", \n",
    "                 \"joined\": 2022, \n",
    "                 \"address 1\": \"12309 Scratch Tree Lane\", \n",
    "                 \"city\": \"Beverly Hills\", \n",
    "                 \"state\": \"CA\", \n",
    "                 \"subscriptions\" : ['Little Known Hiss-tories podcast']}\n",
    "member_info_2 = {\"name\": \"Pete\", \n",
    "                 \"joined\": 2018, \n",
    "                 \"address 1\": \"501 Grumpy Street\", \n",
    "                 \"city\": \"Long Beach\", \n",
    "                 \"state\": \"California\", \n",
    "                 \"subscriptions\" : ['Leisure Cats magazine','Little Known Hiss-tories podcast']}\n",
    "member_info_3 = {\"name\": \"Omar\", \n",
    "                 \"joined\": 2008, \n",
    "                 \"address 1\": \"9 Catnado Way\", \n",
    "                 \"city\": \"Bellevue\", \n",
    "                 \"state\": \"WA\", \n",
    "                 \"subscriptions\" : []}\n",
    "member_info_4 = {\"name\": \"Carla\", \n",
    "                 \"joined\": 2006, \n",
    "                 \"address 1\": \"2120 Curious Court\", \n",
    "                 \"city\": \"Raleigh\", \n",
    "                 \"state\": \"North Carolina\", \n",
    "                 \"subscriptions\" : ['email newsletter', 'Cat Nips subscription box']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H7TP80gtv5dc",
    "outputId": "b86b93a0-77af-425a-e766-56ba134d352b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Bill',\n",
       "  'joined': 2022,\n",
       "  'address 1': '12309 Scratch Tree Lane',\n",
       "  'city': 'Beverly Hills',\n",
       "  'state': 'CA',\n",
       "  'subscriptions': ['Little Known Hiss-tories podcast']},\n",
       " {'name': 'Pete',\n",
       "  'joined': 2018,\n",
       "  'address 1': '501 Grumpy Street',\n",
       "  'city': 'Long Beach',\n",
       "  'state': 'California',\n",
       "  'subscriptions': ['Leisure Cats magazine',\n",
       "   'Little Known Hiss-tories podcast']},\n",
       " {'name': 'Omar',\n",
       "  'joined': 2008,\n",
       "  'address 1': '9 Catnado Way',\n",
       "  'city': 'Bellevue',\n",
       "  'state': 'WA',\n",
       "  'subscriptions': []},\n",
       " {'name': 'Carla',\n",
       "  'joined': 2006,\n",
       "  'address 1': '2120 Curious Court',\n",
       "  'city': 'Raleigh',\n",
       "  'state': 'North Carolina',\n",
       "  'subscriptions': ['email newsletter', 'Cat Nips subscription box']}]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combine the member info from the first activity into a list\n",
    "members = [member_info_1, member_info_2, member_info_3, member_info_4]\n",
    "members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JSR57aaVvGoC",
    "outputId": "c6278d24-8b30-4a54-8120-18cb9af6d8ac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State name correct for Bill\n",
      "Fix California for Pete\n",
      "State name correct for Omar\n",
      "Fix North Carolina for Carla\n"
     ]
    }
   ],
   "source": [
    "# Loop over the member info contained in the list \"members\" to test if state\n",
    "# listing is correctly formatted\n",
    "for member in members:\n",
    "    if len(member[\"state\"]) > 2:\n",
    "        print(\"Fix \" + member[\"state\"] + \" for \" + member[\"name\"])\n",
    "    else:\n",
    "        print(\"State name correct for \" + member[\"name\"])"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Introduction_to_Programming_with_Python_2_filled.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "interpreter": {
   "hash": "0bb8fac8a0c82f4f5ccbcc488a26fe869e7789c40997937e38e89b37cd70a2e8"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}