day1/3 Organizing Data into Dictionaries (solutions).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parsing Metadata from Filenames: Working with Strings, Lists, and Dicts\n",
    "\n",
    "In this section, we delve into the practical application of Python data structures such as dictionaries, lists, and strings, focusing particularly on extracting and managing metadata. As neuroscience grad students, you are likely encountering experimental data that needs organized and structured management. Metadata, or data about data, often comes in various formats, and filenames can be a rich source. This section guides you in extracting and manipulating this information to make your data analysis more structured and less error-prone.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key-Value Mappings: Dictionaries\n",
    "\n",
    "As neuroscience researchers, we often encounter scenarios where you need to associate specific values with unique identifiers – be it experimental conditions, subject details, or measurement parameters. This section introduces dictionaries in Python, a versatile data structure ideal for storing and retrieving data through key-value pairs:\n",
    "\n",
    "```python\n",
    "{\"name\": \"Emma\",   \"Date\": \"2022-07-23\"}\n",
    "#--Key----Value-   -Key-------Value----\n",
    "```\n",
    "\n",
    "You start with basic dictionary operations, such as creating, adding, and accessing elements. This hands-on experience familiarizes you with dictionary syntax and operations. The exercises are designed to reflect realistic use cases, such as storing and accessing metadata from experimental recordings.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| Code | Description |\n",
    "| :-- | :-- |\n",
    "| data = {} | Makes an empty Dict | \n",
    "| data = {'a': 3, 'b': 5} | Makes a Dict with two items: \"a\" and \"b\" |\n",
    "| data['a'] | Accesses the value associated with key 'a' |\n",
    "| data['c'] = 7 | Adds a new key-value pair 'c': 7 to the Dict |\n",
    "| list(data.keys()) | Retrieves a list of all keys in the Dict |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercises**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `image` dict describes how researcher Tom's recording is formatted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'height': 1920, 'width': 1080, 'format': 'RGB', 'order': 'F'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = {'height': 1920, 'width': 1080, 'format': 'RGB', 'order': 'F'}\n",
    "image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: Write the code to print out the width of the image, by accessing the `\"width\"` key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1080"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image['width']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the height of the image?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1920"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image['height']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How are the pixel data in the image formatted?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'RGB'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image['format']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does the error message say, if you use the same syntax to find out which key has the value `1080` ?  What does this tell you about how key-value maps like Dictionaries are designed for?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'image' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[1;32mIn[14], line 1\u001b[0m\n",
      "\u001b[1;32m----> 1\u001b[0m \u001b[43mimage\u001b[49m[\u001b[38;5;241m1080\u001b[39m]\n",
      "\n",
      "\u001b[1;31mNameError\u001b[0m: name 'image' is not defined"
     ]
    }
   ],
   "source": [
    "image[1080]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a dictionary: Reorganize the code below: tell Python that the three variables below all belong together by putting them into a dictionary called `session`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subject': 'Josie', 'date': '2023-07-23', 'group': 'control'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "subject = \"Josie\"\n",
    "date = \"2023-07-23\"\n",
    "group = \"control\"\n",
    "\n",
    "session = {'subject': subject, 'date': date, 'group': group}\n",
    "session"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that the dictionary is constructed properly by getting the subject from it. It should show \"Josie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Josie'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "session['subject']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subject': 'Allan',\n",
       " 'experimenter': 'Barbie',\n",
       " 'time': '09:00',\n",
       " 'notes': 'Did a good job.'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "default_session = {'subject': 'Ken', 'experimenter': 'Barbie', 'time': '09:00', 'notes': 'Nothing new.'}\n",
    "today_vars = {'subject':  'Allan', 'notes': 'Did a good job.'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysing Data stored in Dicts\n",
    "\n",
    "The challenge with analyzing `dict` data is that dicts are not \"sequences\", and neither are `dict_keys()` or `dict_values()`, so before putting them into a statistics function we should first turn `dict_values()` into a `list` using the `list()` function. For example:\n",
    "\n",
    "```python\n",
    ">>> data = {'x': 1, 'y': 2}\n",
    "\n",
    ">>> data.values()\n",
    "dict_values([1, 2])\n",
    "\n",
    ">>> list(data.values())\n",
    "[1, 2]\n",
    "\n",
    ">>> np.mean(list(data.values()))\n",
    "1.5\n",
    "```\n",
    "\n",
    "Useful Functions for the below Exercises:\n",
    "\n",
    "| Function | Example | Description |\n",
    "| :----  | :----   | :---- |\n",
    "| `len()` | `len(the_dict)` | The total number of items |\n",
    "| `np.mean()` | `np.mean(list(the_dict.values())` | The mean of the dict's values |\n",
    "| `np.min()` | `np.min(list(the_dict.values()))` | The minimum of the dict's values |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercises**: Let's get some practice querying dicts and calculating some statistics on dicts using Numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the following dict, calculate what was the average hours of sleep that our friends got last night:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hours_of_sleep = {'Jason': 5, 'Kimberly': 9, 'Billy': 7, 'Trini': 6, 'Zack': 8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean(list(hours_of_sleep.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many total people in the following dataset were in our sleep study?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hours_of_sleep = {'Jason': 5, 'Kimberly': 9, 'Billy': 7, 'Trini': 6, 'Zack': 8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "len(hours_of_sleep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What was the average amount of sleep on day 2 in the following dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hours_of_sleep = {\n",
    "    'Day1': [5, 7, 3, 3, 4, 6, 8, 9],\n",
    "    'Day2': [5, 7, 8, 5, 6, 7, 8, 4],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean(hours_of_sleep['Day2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following dataset to answer the questions below\n",
    "\n",
    "*Tip*: you can index multiple times (e.g. `data['Monday']['Morning']` or `data['Monday'].keys()`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hours_of_sleep = {\n",
    "    'Day1': {'Jason': 5, 'Kimberly': 9, 'Billy': 7, 'Trini': 6, 'Zack': 8},\n",
    "    'Day2': {'Billy': 10, 'Kimberly': 7, 'Trini': 7, 'Jason': 4},\n",
    "    'Day3': {'Trini': 8, 'Zack': 6, 'Jason': 9, 'Billy': 9},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example*: How many hours of sleep did Trini get on Day 2?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hours_of_sleep['Day2']['Trini']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many hours of sleep did Billy get on Day 1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hours_of_sleep['Day1']['Billy']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How much sleep did Zack get on Day 3?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hours_of_sleep['Day3']['Zack']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many people were in the study on Day 1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "len(hours_of_sleep['Day1'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many people were still in the study on Day 3?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "len(hours_of_sleep['Day3'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was the average amount of sleep higher on day one or day three?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7.0, 8.0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "day1 = np.mean(list(hours_of_sleep['Day1'].values()))\n",
    "day3 = np.mean(list(hours_of_sleep['Day3'].values()))\n",
    "day1, day3"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "duckdb",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}