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, including 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).\n",
    "\n",
    "### 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.\n",
    "\n",
    "### 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": [
    "## 2.&nbsp;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, move to different lines of code, or 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": [
    "### 2.1&nbsp;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": null,
   "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": [],
   "source": [
    "# Compare numbers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dbjij2HOZGYO",
    "outputId": "d1e14040-7e5e-4058-bbc0-3e67d8a6f9d0"
   },
   "outputs": [],
   "source": [
    "# Compare strings\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RcTJdQUpSmgY",
    "outputId": "ccdf7d86-df30-4c6e-f448-16b9577e751b"
   },
   "outputs": [],
   "source": [
    "# Compare other expressions using multiple data types\n"
   ]
  },
  {
   "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": null,
   "metadata": {
    "id": "aT-bNlRwz7vG"
   },
   "outputs": [],
   "source": [
    "len([1, 2]) == 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2&nbsp;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",
    "<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",
    "- `or` for at least one condition to be true\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",
    "- `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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a variable to use in the following examples\n",
    "num = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The \"and\" operator checks if both conditions are True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The \"or\" operator checks if at least one of the conditions are True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The \"not\" operator returns the opposite of the return of a comparison\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "\n",
    "\n",
    "# Results with parentheses\n"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "v-LYg5HFTqqS"
   },
   "source": [
    "### 2.3&nbsp;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": [
    "#### 2.3.1&nbsp;If, Else (`if`, `else`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EDJp21NoHIwv",
    "outputId": "ae92d0ac-34ca-4181-9810-22c50600a796"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.2&nbsp;If, Else if, Else (`if`, `elif`, `else`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NdAGrsNTHIwz",
    "outputId": "9979185f-a13b-4c01-8e96-32e6eacf4766"
   },
   "outputs": [],
   "source": [
    "# You can use if, else if (\"elif\"), and else to specify more than one condition\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oM5eWA7bmdl5",
    "outputId": "65314e08-028a-4186-ed22-dfbf0702febd"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tsekt_Q0sK28",
    "outputId": "39ff0aeb-64e0-4f27-f2de-c10a2fe529ec"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A list of my cats\n",
    "my_cats = [\"Sally\", \"Bob\"]\n",
    "\n",
    "cat_name = \"Bill\"\n",
    "\n",
    "# Print \"This is my cat!\" if a name is in \"my_cats\"\n"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Ay8ASNZ5Dhga"
   },
   "source": [
    "## Five (5) Minute Break"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "Budxyg0zT4eK"
   },
   "source": [
    "### 2.4&nbsp;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/control_flow.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D0rVgXIxn8XS",
    "outputId": "e57b6f34-0a92-4ab0-827b-ae4e37db218d"
   },
   "outputs": [],
   "source": [
    "# Iterate over a range using the \"range()\" function\n",
    "# The range function returns a sequence of numbers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zXdkrbOFtOJo",
    "outputId": "e053a9c6-c70b-4be4-96d8-b56417db5e85"
   },
   "outputs": [],
   "source": [
    "# Iterate over a string\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "quma-JNWHIw3",
    "outputId": "751daf19-a5a2-4736-8cfd-0cc946eefc5e"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "\n",
    "\n",
    "# Iterate using a dictionary's keys to get the values\n",
    "# See also dict.values()\n",
    "\n",
    "\n",
    "# Iterate using a dictionary's keys and values\n",
    "# See also dict.items()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oMXUE6vQHIw5",
    "outputId": "f2ab818d-1b41-41c4-e1fd-f5d57e1bee2d"
   },
   "outputs": [],
   "source": [
    "# You can combine types of control flow, this is called \"nesting\"\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "aTFfhbLqT_fC"
   },
   "source": [
    "### 2.5&nbsp;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": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NY2cs8OyHIxA",
    "outputId": "1ecc8a8e-b294-48a9-928e-40abe128db79"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_pB53kxgHIxD",
    "outputId": "c05506b0-c0f1-41e3-89ce-da70fc2226be"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A list of cat names\n",
    "cat_names = [\"Bob\", \"Bill\", \"Pete\", \"Carla\", \"Sally\"]\n"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_grades = [95, 62, 75, 80]\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.&nbsp;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": null,
   "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\": 2023, \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": null,
   "metadata": {},
   "outputs": [],
   "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",
    "# Write your code here\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "FgsqJZovHIxS"
   },
   "source": [
    "## Further resources and topics\n",
    "\n",
    "### Filled version of this notebook\n",
    "\n",
    "[Introduction to Programming with Python - Part 2 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_2.ipynb) - a version of this notebook without code filled in for the guided activity and exercises. Use the filled version for reference and to check exercise solutions.\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": null,
   "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\": 2021, \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": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H7TP80gtv5dc",
    "outputId": "b86b93a0-77af-425a-e766-56ba134d352b"
   },
   "outputs": [],
   "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]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JSR57aaVvGoC",
    "outputId": "c6278d24-8b30-4a54-8120-18cb9af6d8ac"
   },
   "outputs": [],
   "source": [
    "# Loop over the member info contained in the list \"members\" to test if state\n",
    "# listing is correctly formatted\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Introduction_to_Programming_with_Python_2",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}