03-data-structures-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming and Data Analysis\n",
    "\n",
    "> Data Structures in Python\n",
    "\n",
    "Kuo, Yao-Jen <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a data structure?\n",
    "\n",
    "> In computer science, a data structure is a data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Data_structure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why data structure?\n",
    "\n",
    "As a software engineer, the main job is to perform operations on data, we can simplify that operation into: \n",
    "\n",
    "1. Take some input\n",
    "2. Process it\n",
    "3. Return the output\n",
    "\n",
    "Quite similar to what we've got from the definition of a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## To make the process efficient, we need to optimize it via data structure\n",
    "\n",
    "Data structure decides how and where we put the data to be processed. A good choice of data structure can enhance our efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We will talk about 4 built-in data structures in Python\n",
    "\n",
    "- `list`\n",
    "- `tuple`\n",
    "- `dict` as in dictionary\n",
    "- `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Built-in data structures refer to those need no self-definition or importing\n",
    "\n",
    "Quite similar to the comparison of built-in functions vs. self-defined/third party functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `list`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists\n",
    "\n",
    "Lists are the basic ordered and mutable data collection type in Python. They can be defined with comma-separated values between brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "print(type(primes)) # use type() to check type\n",
    "print(len(primes))  # use len() to check how many elements are stored in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists have a number of useful methods\n",
    "\n",
    "- `.append()`\n",
    "- `.pop()`\n",
    "- `.remove()`\n",
    "- `.insert()`\n",
    "- `.sort()`\n",
    "- ...etc.\n",
    "\n",
    "We can use `TAB` and `SHIFT - TAB` for documentation prompts in a notebook environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Different ways to update an object\n",
    "\n",
    "- **Return** a new object that has been updated.\n",
    "- **Update** the object itself and return `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The difference between `sorted()` function and a list's `sort()` method\n",
    "\n",
    "- Return a new list containing all items from the iterable in ascending order.\n",
    "- Sort the list in ascending order and return None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13]\n",
      "[2, 3, 5, 7, 11]\n",
      "[3, 5, 7, 11]\n",
      "[2, 3, 5, 7, 11]\n",
      "[11, 7, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "primes.append(13) # appending an element to the end of a list\n",
    "print(primes)\n",
    "primes.pop() # popping out the last element of a list\n",
    "print(primes)\n",
    "primes.remove(2) # removing the first occurance of an element within a list\n",
    "print(primes)\n",
    "primes.insert(0, 2) # inserting certain element at a specific index\n",
    "print(primes)\n",
    "primes.sort(reverse=True) # sorting a list, reverse=False => ascending order; reverse=True => descending order\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python provides access to elements in compound types through\n",
    "\n",
    "- **indexing** for a single element\n",
    "- **slicing** for multiple elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python uses zero-based indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "primes.sort()\n",
    "print(primes[0]) # the first element\n",
    "print(primes[1]) # the second element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Elements at the end of the list can be accessed with negative numbers, starting from -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "print(primes[-1]) # the last element\n",
    "print(primes[-2]) # the second last element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## While indexing means fetching a single value from the list, slicing means accessing multiple values in sub-lists\n",
    "\n",
    "- start(inclusive)\n",
    "- stop(non-inclusive)\n",
    "- step\n",
    "\n",
    "```python\n",
    "# slicing syntax\n",
    "LIST[start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n",
      "[5, 7, 11]\n",
      "[2, 5, 11]\n"
     ]
    }
   ],
   "source": [
    "print(primes[0:3:1]) # slicing the first 3 elements\n",
    "print(primes[-3:len(primes):1]) # slicing the last 3 elements \n",
    "print(primes[0:len(primes):2]) # slicing every second element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If leaving out, it defaults to\n",
    "\n",
    "- start: 0\n",
    "- stop: len(list)\n",
    "- step: 1\n",
    "\n",
    "So we can do the same slicing with defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n",
      "[5, 7, 11]\n",
      "[2, 5, 11]\n",
      "[11, 7, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(primes[:3]) # slicing the first 3 elements\n",
    "print(primes[-3:]) # slicing the last 3 elements \n",
    "print(primes[::2]) # slicing every second element\n",
    "print(primes[::-1]) # a particularly useful tip is to specify a negative step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `tuple`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuples\n",
    "\n",
    "Tuples are in many ways similar to lists, but they are defined with parentheses rather than brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = (2, 3, 5, 7, 11)\n",
    "print(type(primes)) # use type() to check type\n",
    "print(len(primes))  # use len() to check how many elements are stored in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The main distinguishing feature of tuples is that they are immutable\n",
    "\n",
    "Once they are created, their size and contents cannot be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 13]\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "primes[-1] = 13\n",
    "print(primes)\n",
    "primes = tuple(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tuple' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    primes[-1] = 11\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use TAB to see if there is any mutable method for tuple\n",
    "\n",
    "```python\n",
    "TUPLE.<TAB>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuples are often used in a Python program; like functions that have multiple return values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Taiwan', 'Taipei')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def get_locale(country: str, city: str) -> str:\n",
    "    return country, city\n",
    "\n",
    "print(get_locale(\"Taiwan\", \"Taipei\"))\n",
    "print(type(get_locale(\"Taiwan\", \"Taipei\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multiple return values can also be individually assigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taiwan\n",
      "Taipei\n"
     ]
    }
   ],
   "source": [
    "my_country, my_city = get_locale(\"Taiwan\", \"Taipei\")\n",
    "print(my_country)\n",
    "print(my_city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `dict`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are extremely flexible mappings of keys to values, and form the basis of much of Python's internal implementation. They can be created via a comma-separated list of `key:value` pairs within braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "boston_celtics = {\n",
    "    'isNBAFranchise': True,\n",
    "    'city': \"Boston\",\n",
    "    'fullName': \"Boston Celtics\",\n",
    "    'tricode': \"BOS\",\n",
    "    'teamId': 1610612738,\n",
    "    'nickname': \"Celtics\",\n",
    "    'confName': \"East\",\n",
    "    'divName': \"Atlantic\"\n",
    "}\n",
    "\n",
    "print(type(boston_celtics))\n",
    "print(len(boston_celtics))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Elements are accessed through valid key rather than zero-based order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boston\n",
      "East\n",
      "Atlantic\n"
     ]
    }
   ],
   "source": [
    "print(boston_celtics['city'])\n",
    "print(boston_celtics['confName'])\n",
    "print(boston_celtics['divName'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## New key:value pair can be set smoothly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'isNBAFranchise': True, 'city': 'Boston', 'fullName': 'Boston Celtics', 'tricode': 'BOS', 'teamId': 1610612738, 'nickname': 'Celtics', 'confName': 'East', 'divName': 'Atlantic', 'isMyFavorite': True}\n"
     ]
    }
   ],
   "source": [
    "boston_celtics['isMyFavorite'] = True\n",
    "print(boston_celtics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `del` to remove a key:value pair from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'isNBAFranchise': True, 'city': 'Boston', 'fullName': 'Boston Celtics', 'tricode': 'BOS', 'teamId': 1610612738, 'nickname': 'Celtics', 'confName': 'East', 'divName': 'Atlantic'}\n"
     ]
    }
   ],
   "source": [
    "del boston_celtics['isMyFavorite']\n",
    "print(boston_celtics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common mehtods called on dictionaries\n",
    "\n",
    "- `.keys()`\n",
    "- `.values()`\n",
    "- `.items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['isNBAFranchise', 'city', 'fullName', 'tricode', 'teamId', 'nickname', 'confName', 'divName'])\n",
      "dict_values([True, 'Boston', 'Boston Celtics', 'BOS', 1610612738, 'Celtics', 'East', 'Atlantic'])\n",
      "dict_items([('isNBAFranchise', True), ('city', 'Boston'), ('fullName', 'Boston Celtics'), ('tricode', 'BOS'), ('teamId', 1610612738), ('nickname', 'Celtics'), ('confName', 'East'), ('divName', 'Atlantic')])\n"
     ]
    }
   ],
   "source": [
    "print(boston_celtics.keys())\n",
    "print(boston_celtics.values())\n",
    "print(boston_celtics.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sets\n",
    "\n",
    "The fourth basic collection is the set, which contains unordered collections of unique items. They are defined much like lists and tuples, except they use the braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = {2, 3, 5, 7, 11}\n",
    "odds = {1, 3, 5, 7, 9}\n",
    "print(type(primes))\n",
    "print(len(odds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python's sets have all of the operations like union, intersection, difference, and symmetric difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set operators\n",
    "\n",
    "- `|`: Union operator.\n",
    "- `&`: Intersection operator.\n",
    "- `-`: Difference operator.\n",
    "- `^`: Symmetric difference operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Union: elements appearing in either sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5, 7, 9, 11}\n",
      "{1, 2, 3, 5, 7, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "print(primes | odds)      # with an operator\n",
    "print(primes.union(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Intersection: elements appearing in both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 5, 7}\n",
      "{3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "print(primes & odds)             # with an operator\n",
    "print(primes.intersection(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Difference: elements in primes but not in odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 11}\n",
      "{2, 11}\n"
     ]
    }
   ],
   "source": [
    "print(primes - odds)           # with an operator\n",
    "print(primes.difference(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Symmetric difference: items appearing in only one set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 9, 11]\n",
      "{1, 2, 9, 11}\n",
      "{1, 2, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "print(sorted((primes - odds) | (odds - primes))) # union two differences\n",
    "print(primes ^ odds)                             # with an operator\n",
    "print(primes.symmetric_difference(odds))         # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An overview of when to use parentheses, brackets, or braces\n",
    "\n",
    "- Parentheses `()`\n",
    "- Brackets `[]`\n",
    "- Braces `{}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Parentheses `()`\n",
    "\n",
    "- Precedence of operation.\n",
    "- Calling a function.\n",
    "- Calling a method.\n",
    "- To form a `tuple`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Brackets `[]`\n",
    "\n",
    "- To form a `list`.\n",
    "- Indexing/Slicing element(s) from a data structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Braces `{}`\n",
    "\n",
    "- To be inserted in strings as placeholders in `.format()` or f-strings.\n",
    "- To form a `dict` with `key: value` pairs.\n",
    "- To form a `set`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##  One of the powerful features of Python's compound objects is that they can contain objects of any type, or even a mix of types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##  Take data.nba.net for example\n",
    "\n",
    "The official API of NBA is a bunch of compound dictionaries contained other dictionaries/lists as values.\n",
    "\n",
    "Source: <https://data.nba.net/10s/prod/v1/today.json>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##  Take another basketball API for example\n",
    "\n",
    "The balldontlie API is also a bunch of compound dictionaries contained other dictionaries/lists as values.\n",
    "\n",
    "Source: <https://www.balldontlie.io/api/v1/players>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}