A_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X10VLY3s0TUq"
   },
   "source": [
    "### Using Jupyter Notebooks and Pandas to Work with Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lnxLSAp-0fU7"
   },
   "source": [
    "## A. Introduction\n",
    "\n",
    "\n",
    "* **Jupyter Notebooks** allow anyone to run **Python** code in any browser, without the need to use the terminal or command line\n",
    "\n",
    "* **Jupyter Notebooks** are organized as 'cells', which can be **commentary** (like this one, which is static), or **code** (those below, which produce dyanmic output in the form of charts or tabular data frames.  \n",
    "\n",
    "* To run an individual cell, use the **`arrow/run`** command at the top of the Notebook, or just press **`Shift + Enter`** on your keyboard.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1660070692072,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "92qEoeNz1Nom",
    "outputId": "82c4b40c-b4a5-45ff-d062-1fc2146ef98a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my First Notebook\n"
     ]
    }
   ],
   "source": [
    "print(\"This is my First Notebook\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gt_f_zcB1Zdc"
   },
   "source": [
    "# Introduction\n",
    "In Python, like other programming languages, we declare **variables**, then use **functions** transform them in various ways.  There are functions (and libraries) that help us work with numbers, text, statistics, graphs, etc.\n",
    "\n",
    "Read more about Python with this easy reference guide:  https://www.w3schools.com/python/python_intro.asp\n",
    "\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Data Types\n",
    "It's important to understand **data types**:\n",
    "\n",
    "*   **integer**:  any whole number, such as 1, 2, 10\n",
    "\n",
    "*   **float**:  decimal numbers, such as 2.25, 6.875\n",
    "\n",
    "*   **string**:   any alpha-numeric character, surrounded by quotation marks (double or single)\n",
    "*   **Boolean**:  True or False (in fact these are reserved words in Python and should not be used beyond Boolean functions)\n",
    "\n",
    "---\n",
    "# Collections\n",
    "These can also be combined as various kind of **collections**:\n",
    "\n",
    "*   **lists**:  an ordered sequence presented in brackets and separated by commas, such as **[\"Blues\", \"Gospel\", \"Country\"]** or **[1.0, 4.0, 6.0]**.  Lists can contain duplicates\n",
    "*   **set**:  an unordered sequence; it cannot contain duplicates\n",
    "*   **tuples**: a special kind of list that cannot be altered, presented as **(\"Jazz\", \"Classical\", \"Folk\")** or **(1.25, 4.76, 8.03)**\n",
    "\n",
    "*   **dictionaries**:  a series of **key : value** pairs contained within braces, such as **{\"artist\" : \"McCartney, Paul\", \"title\" : \"Yesterday\"}**\n",
    "\n",
    "Read more about Python data types here:  https://www.w3schools.com/python/python_datatypes.asp\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "13K1Gch35T5o"
   },
   "source": [
    "# Checking Data Types\n",
    "\n",
    "Check the **data type** of any item:\n",
    "\n",
    "`type(item)`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "aOnopTIU5Snv"
   },
   "outputs": [],
   "source": [
    "item_1 = 'guitar'\n",
    "item_2 = 1\n",
    "item_3 = 2.25\n",
    "item_4 = True\n",
    "item_5 = [\"Blues\", \"Gospel\", \"Country\", 4] \n",
    "item_6 = (\"Jazz\", \"Classical\", \"Folk\")\n",
    "item_7 = {\"artist_surname\" : \"McCartney\", \"artist_given_name\" : \"Paul\", \"title\" : \"Yesterday\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that simply defining a variable does not produce any output. \n",
    "If you want to see the value of a variable, you can print it:\n",
    "\n",
    "`print(my_variable)`\n",
    "\n",
    "or just write it as the last line in the cell:\n",
    "\n",
    "`my_variable`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8FRKq87ABzVR"
   },
   "source": [
    "# Numbers, Strings, Floats, and Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kl8aQpRj6Usx"
   },
   "source": [
    "Depending on the data type, it's possible to perform various **operations** on them.\n",
    "\n",
    "* You **can** add/subtract **integers** and **floats** to each other\n",
    "* You **cannot** add an **integer** to **text or a Boolean**\n",
    "* Many other kinds of operators can be used to compare items, test for thresholds, etc.  \n",
    "\n",
    "**Integers** and **floats** can be used with various mathematical tests:\n",
    "\n",
    "```\n",
    "Equals: a == b\n",
    "Not Equals: a != b\n",
    "Less than: a < b\n",
    "Less than or equal to: a <= b\n",
    "Greater than: a > b\n",
    "Greater than or equal to: a >= b\n",
    "```\n",
    "\n",
    "\n",
    "Read about operators here:  https://www.w3schools.com/python/python_operators.asp\n",
    "\n",
    "\n",
    "**Strings** are text.  There are a wide variety of built-in methods that allow to you to work with them to:\n",
    "\n",
    "* change lower/upper case\n",
    "* strip out certain characters (like punctuation)\n",
    "* split texts (at spaces, for example)\n",
    "* find substrings, or first/last characters\n",
    "* etc!\n",
    "\n",
    "See more [here](https://www.w3schools.com/python/python_strings_methods.asp).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jS-RDZsHAdef"
   },
   "source": [
    "\n",
    "# Your Turn with Data Types\n",
    "\n",
    "\n",
    "**Create** some variables (along the lines proposed above).  \n",
    "You can name them what you like, but be sure to create different data types.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try **adding** some of the variables from above to each other.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1660070692073,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "7-qCCb9I5lzs",
    "outputId": "14053d77-693d-4811-ab50-3b9fb953c434"
   },
   "source": [
    "\n",
    "\n",
    "Which combinations return errors?  Why?\n",
    "(You can write \"commentary\" within code cells using \"#\" at the start of any line).\n",
    "\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tNH_DJuU7EQF"
   },
   "source": [
    "# Collections:  Lists, Dictionaries, Sets, and Tuples\n",
    "\n",
    "In Python, items gathered together are called a **collection**. There are four types, each with its own properties: \n",
    "\n",
    "* **Lists** are used to store an **ordered sequence of  items** in a single variable.  Each item is surrounded by quotation marks, separated by a comma from the next. Square brackets surround the whole.  The example below is a list of strings (note the quotation marks). See more [here](https://www.w3schools.com/python/python_lists.asp).\n",
    "\n",
    "```\n",
    "list_of_genres =  [\"Blues\", \"Gospel\", \"Country\", \"Hip-Hop\"] \n",
    "```\n",
    "\n",
    "* **Sets** are like lists, but are **not ordered**, and cannot contain duplicates. See more [here](https://www.w3schools.com/python/python_sets.asp).\n",
    "\n",
    "```\n",
    "set(list_of_genres)\n",
    "{'Blues', 'Country', 'Gospel', 'Hip-Hop'}\n",
    "\n",
    "```\n",
    "> Turn a set back into a list:  \n",
    "\n",
    "```\n",
    "list(set(list_of_genres)\n",
    "```\n",
    "\n",
    "* **Dictionaries** are used to store data values in **key:value pairs**. Like lists, they are ordered. But like sets they do not allow duplicates. Each key or value is surrounded by quotation marks. Each key:value pair is followed by a comma. Curly brackets surround the whole. Dictionaries can also contain other dictionaries, as 'nested' dictionaries. See more [here](https://www.w3schools.com/python/python_dictionaries.asp) and below.\n",
    "\n",
    ">    In this example the **keys** and **values** are both strings.  But we could also restrict certain data types.  For instance, we could insist that the `date` value be that specific data type (and not just a string).\n",
    "\n",
    "```\n",
    "my_dict = {\"artist_first_name\" : \"Wolfgang Amadeus\",\n",
    "\"artist_last_name\" : \"Mozart\",\n",
    "\"work_title\" : \"The Magic Flute\",\n",
    "\"work_genre\" : \"singspiel\",\n",
    "\"date\" : \"1791\",\n",
    "\"first_performance_place\" : \"Vienna\"}\n",
    "```\n",
    "\n",
    "* **Tuples** are a special type of collection:  ordered (like lists), but unchangeable (it is not possible to add or remove items). See more [here](https://www.w3schools.com/python/python_tuples.asp). \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_1pobHMTuRJc"
   },
   "source": [
    "# Working with Lists\n",
    "In the case of lists, we often need to:\n",
    "* **Add or remove items**, as in `my_list.append(another_item)` or `my_list.remove(some_item)`\n",
    "* Find out **how many items** are in a list (that is, the \"length\"), such as `len(my_list)`\n",
    "* Find the **unique items** in a list (that is, the \"set\"), such as `set(my_list)`.\n",
    "* Find **how many unique items** there are in a given list, which is the \"length\" of the \"set\": `len(set(my_list))`.  Note the nested parentheses!\n",
    "* Find particular **items by their index** (= position in the list): `my_list[0]` (remember that the index of first position is always \"0\").  The last item in a list is `my_list[-1]` (a \"negative index\" counts back from the end, starting with \"-1\").\n",
    "* Find the **index (= position)** of a particular item: `my_list.index(item_name)`.  This will return a value, rather than the item in question.\n",
    "* **Sort** the list: ``my_list.sort()``, or in reverse alphabetical order: ``my_list.sort(reverse = True)``\n",
    "\n",
    "**Note** that there are many other ways to work with lists, including methods for find a **range** of items (\"the first 10 items\", \"every other item\", \"all but the first and last items\").\n",
    "\n",
    "**Note** that some methods modify a list but don't show you the result. In order to see the modification, output the new list by just typing the name of the list again.  It can be confusing!\n",
    "\n",
    "Read more about working with **Lists** here:  https://www.w3schools.com/python/python_lists.asp\n",
    "\n",
    "Try them out:  https://www.w3schools.com/python/python_lists_exercises.asp\n",
    "\n",
    "Read the methods: https://www.w3schools.com/python/python_lists_methods.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BfRSpM2BCJp5"
   },
   "source": [
    "# Your turn with lists:\n",
    "\n",
    "In the cells below you will . . . \n",
    "* **Create a list** of names, like `my_list = [\"Paul McCartney\", \"John Lennon\"]`\n",
    "* Find the **length** of the list\n",
    "* Print the **first** item in the list\n",
    "* Find the **last** item on the list (even if you don't know how long the list is!)\n",
    "* Assign the **last** item in the list to a new variable name, 'last', and print that\n",
    "* Find the **index position** of a particular name on your list\n",
    "* **Add** an item to the end of the list\n",
    "* **Remove** a particular value from the list (regardless of value)\n",
    "* **Remove** the item at a particular index position\n",
    "* **Add a duplicate** of the second item on the list to the end of the list\n",
    "* Now that the list has a duplicate value in it, find the **unique values**\n",
    "\n",
    "\n",
    "\n",
    "Read the methods: https://www.w3schools.com/python/python_lists_methods.asp\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Create a list** of names, like `my_list = [\"Paul McCartney\", \"John Lennon\"]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 276,
     "status": "ok",
     "timestamp": 1660070692344,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "8pHypKyG-L2K",
    "outputId": "079514c4-e6d0-494d-825f-d9ad9a1e08e3"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L70kyEmrEtwY"
   },
   "source": [
    "* Find the **length** of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uAQdFDWvEyow"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VA2syiXbEzwk"
   },
   "source": [
    "* Print the **first** item in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 16,
     "status": "ok",
     "timestamp": 1660070692347,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "lk_FWTY1FjAq",
    "outputId": "4eacc9d4-9413-470c-82ec-944d32443567"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1660070692348,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "gk3rf5xkInLz",
    "outputId": "a6c6e108-dd20-4043-b5d5-b85d23146406"
   },
   "source": [
    "* Find the **last** item on the list (even if you don't know how long the list is!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 11,
     "status": "ok",
     "timestamp": 1660070692348,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "eeGEr5VqKEgk",
    "outputId": "c2f72a19-89ab-4273-956a-5d8770555046"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Assign the **last** item in the list to a new variable name, 'last', and output that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Find the **index position** of a particular name on your list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Add** an item to the end of the list and output the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Remove** a particular value from the list and output the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Remove** the item at a particular index position and output the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Add a duplicate** of the second item on the list to the end of the list and output the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now that the list has a duplicate value in it, find the **unique values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pj5EgUYzLctg"
   },
   "source": [
    "# Dictionaries\n",
    "You can think of a dictionary like a small catalog, with a series of unique \"keys\" and their associated \"values\", like:\n",
    "\n",
    "```\n",
    "my_dict = {\"artist_first_name\" : \"Wolfgang Amadeus\",\n",
    "\"artist_last_name\" : \"Mozart\",\n",
    "\"work_title\" : \"The Magic Flute\",\n",
    "\"work_genre\" : \"singspiel\",\n",
    "\"date\" : \"1791\",\n",
    "\"first_performance_place\" : \"Vienna\"}\n",
    "```\n",
    "The values can repeat, but the keys in any dictionary must be unique.\n",
    "\n",
    "There are various ways to:\n",
    "\n",
    "* list the **keys**:  `my_dict.keys()`\n",
    "* list the **values**:  `my_dict.values()`\n",
    "* list all the **items** (both the keys and values): `my_dict.items()`\n",
    "* list the **value for a particular key**: `my_dict[\"date\"]`\n",
    "* update the **value for a particular key**: `my_dict[\"date\"] = \"1789\"`\n",
    "* add a **key/value pair**:  `my_dict[\"language\"] = \"German\"\n",
    "* remove a **key/value pair**: `my_dict.pop(\"language\")\n",
    "\n",
    "It is also possible to encounter **nested dictionaries**, in which one dictionary contains another.  \n",
    "\n",
    "**Nested Dictionaries** are ones in which one dictionary contains another.  For example:\n",
    "\n",
    "For example, this dictionary of works in a concert, each with their own details about composer, title, genre, etc.\n",
    "\n",
    "```\n",
    "my_concert = {\n",
    "    \"work_1\": {\n",
    "        \"composer_first_name\" : \"Wolfgang Amadeus\",\n",
    "        \"composer_last_name\" : \"Mozart\",     \n",
    "        \"work_title\" : \"The Magic Flute\",\n",
    "        \"work_genre\" : \"singspiel\",\n",
    "        \"date\" : \"1791\",\n",
    "        \"first_performance_place\" : \"Vienna\"},\n",
    "    \"work_2\": {\n",
    "        \"composer_first_name\" : \"Giuseppe\",\n",
    "        \"composer_last_name\" : \"Verdi\",     \n",
    "        \"work_title\" : \"Aïda\",\n",
    "        \"work_genre\" : \"opera\",\n",
    "        \"date\" : \"1871\",\n",
    "        \"first_performance_place\" : \"Cairo\"}\n",
    "```\n",
    "\n",
    "Access the **top-level key** 'work_1':\n",
    "\n",
    "```\n",
    "my_concert['work_1']\n",
    "\n",
    "```\n",
    "Access **all the keys nested** within 'work_1':\n",
    "\n",
    "```\n",
    "my_concert['work_1'].keys()\n",
    "\n",
    "```\n",
    "Access an **individual key nested** within 'work_1':\n",
    "\n",
    "```\n",
    "my_concert['work_1']['work_title']\n",
    "```\n",
    "**Add a key/value pair** to one item:\n",
    "\n",
    "```\n",
    "my_concert['work_1'][\"librettist\"] = 'Schickaneder'\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "More [here](https://www.w3schools.com/python/python_dictionaries.asp).\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SLJKiZ6aL31E"
   },
   "source": [
    "# Your Turn with Dictionaries\n",
    "\n",
    "Select a musical object (a work, a musical event, a CD, an instrument) and create a dictionary that captures important information about it. There should be at least **five unique keys** in your dictionary.\n",
    "\n",
    "Then in the cells below, try the following:\n",
    "* **Populate** the keys/value pairs\n",
    "* **List** the keys: `my_dict.keys()`\n",
    "* Save that list as a new variable `list_keys = list(my_dict.keys())`.  Note the nested parentheses!\n",
    "* **Find values** for some of the keys\n",
    "* **Update** certain keys \n",
    "* Pick some related fields in the dictionary and join them up as a new variable, like:\n",
    "\n",
    "```\n",
    "Artist_Full_Name = my_dict[\"artist_first_name\"] + \" \" + my_dict[\"artist_last_name\"]\n",
    "\n",
    "```\n",
    "\n",
    "or\n",
    "\n",
    "```\n",
    "Artist_Surname_Name_Sort = my_dict[\"artist_last_name\"] + \" \" + my_dict[\"artist_first_name\"]\n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Populate** the key/value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5Akm6i7xFUrh"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **List** the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 268,
     "status": "ok",
     "timestamp": 1660070692607,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "4NvXj8L0YNcn",
    "outputId": "e0b06706-889e-4075-bdb0-ec29df55cdcd"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1660070692607,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "JoIhPXWuG9-m",
    "outputId": "41ddb9c5-edeb-490f-b5bd-3063266d9147"
   },
   "source": [
    "* **List** the keys again, but this time **Save** that list as a new variable and output it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1660070692607,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "GrJdJ-puH3Du",
    "outputId": "5d04a4d0-65d6-4151-a141-c7c30edf5bef"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 141,
     "status": "ok",
     "timestamp": 1660071444520,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "Louyd-oL9Y1z",
    "outputId": "7cdf1752-40e2-4fee-b4f6-1b89e1f7581b"
   },
   "source": [
    "* **Find values** for some of the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1660071995310,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "0HqmDPfL_8qG",
    "outputId": "50d0f5a3-6e92-42e9-d571-a5e7b50bee6e"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g-yH784_D5j0"
   },
   "source": [
    "* Pick some related fields in the dictionary and **join them up as a new variable**, like:\n",
    "\n",
    "```\n",
    "Artist_Full_Name = my_dict[\"artist_first_name\"] + \" \" + my_dict[\"artist_last_name\"]\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2,
     "status": "ok",
     "timestamp": 1660073033325,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "l8dM0_QkD9L-",
    "outputId": "ddf57903-4022-4a38-8cea-035542988cb7"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build a **nested dictionary** (like your own **Playlist** or **Collection of Scores or Objects**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the models shown above, **create cells** that:\n",
    "\n",
    "* Show **all the keys** for a particular top-level item\n",
    "* Access a **particular key** within that item\n",
    "* **Add a key** to that item\n",
    "\n",
    "Remember to label them with `# comments` in your code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "48lJkrni946q"
   },
   "source": [
    "# \"If\" statements\n",
    "\n",
    "\"If\" statements allow you to perform **logical tests** on your data, such as:\n",
    "\n",
    "```\n",
    "Equals: a == b\n",
    "Not Equals: a != b\n",
    "Less than: a < b\n",
    "Less than or equal to: a <= b\n",
    "Greater than: a > b\n",
    "Greater than or equal to: a >= b\n",
    "```\n",
    "Examples in \"if\" statement:\n",
    "\n",
    "```\n",
    "if item_value > 10:\n",
    "  print(\"high value\")\n",
    "elif item_value > 5:\n",
    "  print(\"medium value\")\n",
    "else:  # default case, item_value <= 5\n",
    "  print(\"low value\")\n",
    "```\n",
    "\n",
    "or\n",
    "\n",
    "```\n",
    "group_name = \"Beatles\"\n",
    "if group_name.startswith(\"B\"):\n",
    "  print(True)\n",
    "```\n",
    "Note that \"if\" statements can be multi-stage, with **\"if\"** followed by **\"elif\"** (another condition to test if the first condition is not met), and **\"else\"** (a default result if none of the previous tests are true). \n",
    "\n",
    "More about \"if\" statements [here](https://www.w3schools.com/python/python_conditions.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CuJ0eduPShZK"
   },
   "source": [
    "# Your Turn with \"if\" Statements\n",
    "\n",
    "Create some **variables of your own** and try **various logical tests** to determine whether:\n",
    "\n",
    "* integers or other values in the list are above or below a given threshold\n",
    "* text strings begin or end with certain letters (or do not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "teGEviuyOBqM"
   },
   "source": [
    "# \"For\" Loops\n",
    "\"For\" loops allow you to iterate over the items in any collection, performing the same operation or function on each.\n",
    "\n",
    "**Note** loops like are very helpful when working with individual lists or dictionaries.  But you will want to **avoid** attempting to use them directly on a **Pandas column**.  Instead, write the function by \"apply\" it to that column for all rows in the dataframe.  More about that in Notebook B!\n",
    "\n",
    "\n",
    "**\"if\"** statement **within a \"for\"** loop:\n",
    "\n",
    "```\n",
    "genres =  [\"Blues\", \"Gospel\", \"Country\", \"Hip-Hop\"] \n",
    "for genre in genres:\n",
    "  if genre.startswith(\"B\"):\n",
    "    print(genre)\n",
    "\n",
    "```\n",
    "\n",
    "or to all those that do _not_ satisfy the condition:\n",
    "\n",
    "```\n",
    "genres =  [\"Blues\", \"Gospel\", \"Country\", \"Hip-Hop\"] \n",
    "for genre in genres:\n",
    "  if genre.startswith(\"B\"):\n",
    "    pass\n",
    "  else:\n",
    "    print(genre)\n",
    "```\n",
    "\n",
    "Note that **list comprehension** allows you work with lists without the need to create separate **for** loops.  For example:\n",
    "\n",
    "```\n",
    "b_list = [x for x in genres if x.startswith(\"B\")]\n",
    "```\n",
    "\n",
    "More about **list comprehension** [here](https://www.w3schools.com/python/python_lists_comprehension.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1660070692608,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "7JVAqXa7Pbtd",
    "outputId": "eea6a805-457a-4382-b7ec-839ea809cc18"
   },
   "source": [
    "### Your Turn with For Loops\n",
    "\n",
    "Make a list of your own, and try out various if/else tests on them.\n",
    "\n",
    "(Could be a list of artists, pieces, events, objects, keys . . . )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1660070692608,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "wQQRIfTTPvnC",
    "outputId": "80cbb370-a170-4fa3-e019-4b4bd0e59748"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mwJ-p6SHOn_D"
   },
   "source": [
    "\n",
    "### For Loops with Nested Dictionaries\n",
    "\n",
    "Now create a **nested** dictionary based on the one you made above.  This could be a *series of related items* (like songs on a playlist, or instruments in a collection, or scores on your shelf). The id's (or keys) for each item will need to be unique at the highest level, but the keys within each item can repeat.  \n",
    "\n",
    "Sample nested dictionary of works on opera season:\n",
    "\n",
    "```\n",
    "my_operas = {\n",
    "    \"work_1\": {\n",
    "        \"composer_first_name\" : \"Wolfgang Amadeus\",\n",
    "        \"composer_last_name\" : \"Mozart\",     \n",
    "        \"work_title\" : \"The Magic Flute\",\n",
    "        \"work_genre\" : \"singspiel\",\n",
    "        \"date\" : \"1791\",\n",
    "        \"first_performance_place\" : \"Vienna\"},\n",
    "    \"work_2\": {\n",
    "        \"composer_first_name\" : \"Giuseppe\",\n",
    "        \"composer_last_name\" : \"Verdi\",     \n",
    "        \"work_title\" : \"Aïda\",\n",
    "        \"work_genre\" : \"opera\",\n",
    "        \"date\" : \"1871\",\n",
    "        \"first_performance_place\" : \"Cairo\"}\n",
    "```\n",
    "\n",
    "\n",
    "Then try the following to iterate through each work in the dictionary, and then print the individual key-value pairs for each work:\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "for work_id, work_info in my_concert.items():\n",
    "    print(\"\\nWork ID:\", work_id)\n",
    "    \n",
    "    for key in work_info:\n",
    "        print(key + ':', work_info[key])\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kGFHEcPAYPNr"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1660073279454,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "CyVZYVfmZfpc",
    "outputId": "a772046a-3db7-418f-803d-32c254a83c7e"
   },
   "source": [
    "# Your Turn with \"for loops\"\n",
    "\n",
    "Try out a **nested for loop** above on a **nested dictionary** that you create.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 229,
     "status": "ok",
     "timestamp": 1660073280419,
     "user": {
      "displayName": "Richard Freedman",
      "userId": "15551081619854298243"
     },
     "user_tz": 240
    },
    "id": "mUydqjCTa8TK",
    "outputId": "48f07ee9-d00c-42c1-dadf-12e436d7dfc9"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k4Eg2sJsFirD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Functions are just what they sound like:  a short series of steps that can be applied to \n",
    "some data, and **return** various results depending on the logic you apply.\n",
    "\n",
    "We will take a simple example that can be applied later in our work with Pandas data sets.\n",
    "\n",
    "Let's imagine that you have a dataset in which a particular column contains data that are inconsistent:  in some places for the name of an artist you have `John Lennon`, and other places `John Lenin`.  You could correct them by hand in a spreadsheet.  But there is an easier way with a Python **function**.\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "def name_check(sample_name):\n",
    "    if sample_name == \"John Lenin\":\n",
    "        print(\"That should be John Lennon instead\")\n",
    "    else:\n",
    "        print(\"It's spelled correctly\")\n",
    "```\n",
    "\n",
    "So far all we have done is to **define the function** (take note of the \":\" signs and of the indentations.  But now we must actually run it with some data.\n",
    "\n",
    "First on **one** sample name:\n",
    "\n",
    "```\n",
    "sample_name = \"John Lenin\"\n",
    "name_check(sample_name)\n",
    "```\n",
    "\n",
    "Or combined with a **for** loop, we can run this over a list of names:\n",
    "\n",
    "```\n",
    "sample_name_list = [\"John Lenin\", \"John Lennon\", \"John Lenin\"]\n",
    "for sample_name in sample_name_list:\n",
    "    name_check(sample_name)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your Turn with a Function\n",
    "\n",
    "Think of some data that you would like to transform or correct. <br>\n",
    "Write a code to test a sample.<br>\n",
    "Then define a function to test _any_ such sample.<br>\n",
    "And run the function on a list of test values.<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "M255_A_Python_Basics.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}