data-structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures\n",
    "Data Structures are an organised way to store data, and any relationship between the values.\n",
    "\n",
    "Python has several built-in Data Structures like [List](#list), [Tuple](#tuple), [Dictionary](#dictonary). Each element seperated by a `,`.\n",
    "\n",
    ">**Note for the reader:** As this is a Jupyter Notebook, the variables will be shared across code cells, thus, you should keep in mind that, if the variables are already defined somewhere above, they can be used somewhere below **without** defining them again.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutability\n",
    "Mutability = \"changeability\"\n",
    "\n",
    "If a D.S is mutable, then it means that it can be changed, or edited. E.g. list and dictionary.\n",
    "\n",
    "If its immutable, then it **cannot** be edited or changed, or **even called**. It likes a simple constant, like a `string`. E.g. Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List\n",
    "- They are mutable data structures.\n",
    "- They are represented by `[ ]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3] # defining a list\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "- They are **immutable** data structures.\n",
    "- They are represented by `( )`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "t = (1, 2, 3) # defining a tuple\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary\n",
    "- They are mutable data structures.\n",
    "- They are represented by `{ }`.\n",
    "- They exist as \"key-value pairs\". The [indices](#indices) are \"keys\", with corresponding values.\n",
    "\n",
    "Dictionaries can be used to define a \"relationship\" between two things.\n",
    "\n",
    "**Example:**\n",
    "- Iron Man -> Tony Stark\n",
    "- Cap. America -> Steve Rogers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nibir', 'hobbies': 'many'}\n"
     ]
    }
   ],
   "source": [
    "d = {\"name\":\"Nibir\", \"hobbies\":\"many\"}\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictonaries can be \"stylised\" like this to make them more readable and clean:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\n",
    "    \"name\":\"Nibir\", \n",
    "    \"hobbies\":\"many\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indices\n",
    "In Data Structures, each element inside them has a specific \"address\". This address is called the **\"index\"**.\n",
    "This index then can be used for `print()` and other methods.\n",
    "\n",
    "This index **starts from 0**. That means, the first element will have an index of 0, the second of 1, etc.\n",
    "\n",
    "```\n",
    "['a', 'b', 'c']\n",
    "  ^    ^    ^\n",
    "  0    1    2\n",
    "```\n",
    "\n",
    "You can call the element by `variable[index]`\n",
    "\n",
    "### Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rohit\n"
     ]
    }
   ],
   "source": [
    "l = [\"nibir\", \"rohit\", \"pranoy\"] # defining a list\n",
    "\n",
    "print( l[1] ) # print the 2nd element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tony Stark\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    \"Iron Man\":\"Tony Stark\", \n",
    "    \"Cap. America\":\"Steve Rogers\"\n",
    "} # defining a dictionary\n",
    "\n",
    "print( d[\"Iron Man\"] ) # print the 2nd element, that is, \"Iron Man\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for Mutable Objects\n",
    "The mutable data structures, Lists and Dictionaries, share similar functions and methods that you can use to add or remove elements, append, clear, etc.\n",
    "\n",
    "But some are specific for lists and dictionaries each"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Functions\n",
    "These are the functions that are common for **both** Lists and Dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### pop\n",
    "`pop()` removes a particular element by its index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[31, 32, 51, 94]\n"
     ]
    }
   ],
   "source": [
    "# List Example\n",
    "\n",
    "l0 = [31, 48, 32, 51, 94]\n",
    "\n",
    "l0.pop(1) # removes the element \"42\", since its index is 1\n",
    "\n",
    "print(l0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Russia': 'Moscow', 'Italy': 'Rome'}\n"
     ]
    }
   ],
   "source": [
    "# Dictionary Example\n",
    "\n",
    "d0 = { \n",
    "    \"India\":\"New Delhi\", \n",
    "    \"Russia\":\"Moscow\", \n",
    "    \"Italy\": \"Rome\" \n",
    "    }\n",
    "\n",
    "d0.pop(\"India\") \n",
    "\n",
    "print(d0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### clear\n",
    "`clear()` does what it is supposed to: clear whole thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list before clear:  [1, 23, 4, 69]\n",
      "list after clear:  []\n"
     ]
    }
   ],
   "source": [
    "# List example\n",
    "\n",
    "l1 = [1, 23, 4, 69]\n",
    "\n",
    "print(\"list before clear: \", l1)\n",
    "\n",
    "l1.clear()\n",
    "\n",
    "print(\"list after clear: \", l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dictionary before clear:  {'a': 1, 'b': 2, 'c': 3}\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "update expected at most 1 argument, got 2",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[73], line 7\u001b[0m\n\u001b[1;32m      3\u001b[0m d1 \u001b[38;5;241m=\u001b[39m { \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m2\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;241m3\u001b[39m }\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdictionary before clear: \u001b[39m\u001b[38;5;124m\"\u001b[39m, d1)\n\u001b[0;32m----> 7\u001b[0m \u001b[43md1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43ma\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(d1)\n\u001b[1;32m     11\u001b[0m d1\u001b[38;5;241m.\u001b[39mclear()\n",
      "\u001b[0;31mTypeError\u001b[0m: update expected at most 1 argument, got 2"
     ]
    }
   ],
   "source": [
    "# Dictionary example\n",
    "\n",
    "d1 = { \"a\":1, \"b\":2, \"c\":3 }\n",
    "\n",
    "print(\"dictionary before clear: \", d1)\n",
    "\n",
    "d1.clear()\n",
    "\n",
    "print(\"dictionary after clear: \", d1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### len\n",
    "`len()` gives the length of the data structure, that is, how many elements are in them.\n",
    "\n",
    ">**Note:** The length gives out the real no. of elements, and doesn't work like indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list length: 5\n",
      "dict length: 3\n"
     ]
    }
   ],
   "source": [
    "some_list = [11, 90, 39, 42, 56]\n",
    "\n",
    "print(\"list length:\", len(some_list))\n",
    "\n",
    "some_dict = {\n",
    "    \"Judas\":\"Priest\",\n",
    "    \"Iron\":\"Maiden\",\n",
    "    \"AC\":\"DC\"\n",
    "}\n",
    "\n",
    "print(\"dict length:\", len(some_dict))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions for Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### append\n",
    "`append()` allows you to add an element to a list *after* the list ends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Kafka', 'Gogol', 'Murakami', 'Tolstoy']\n"
     ]
    }
   ],
   "source": [
    "authors = ['Kafka', 'Gogol', 'Murakami']\n",
    "\n",
    "authors.append('Tolstoy')\n",
    "\n",
    "print(authors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Overriding list values\n",
    "Alternatively, you can override elements by specifying an index like this:\n",
    "\n",
    "`list[index] = new value`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Kafka', 'Gogol', 'Murakami', 'Bulgakov']\n"
     ]
    }
   ],
   "source": [
    "authors[3] = \"Bulgakov\"\n",
    "\n",
    "print(authors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### insert\n",
    "`insert()` is used to add an element to the list or a dictionary **at a particular index**, without [overriding](#overriding-values).\n",
    "\n",
    "-> `l.insert(index, element)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list before inserting element:  [1, 2, 4, 6]\n",
      "list after:  [1, 2, 'ur mom', 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# List Example\n",
    "\n",
    "l2 = [1, 2, 4, 6]\n",
    "\n",
    "print(\"list before inserting element: \", l2)\n",
    "\n",
    "l2.insert(2, \"ur mom\") # notice the index is 2 and the element is a string \"ur mom\"\n",
    "\n",
    "print(\"list after: \", l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice it just **pushes** the latter elements when it is added."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### remove\n",
    "`remove()` simply removes what you tell it to. This is different from [pop](#pop) as it remove from value, not index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before: [20, 29, 91, 18, 59]\n",
      "after: [20, 29, 18, 59]\n"
     ]
    }
   ],
   "source": [
    "l3 = [20, 29, 91, 18, 59]\n",
    "\n",
    "print(\"before:\", l3)\n",
    "\n",
    "l3.remove(91)\n",
    "\n",
    "print(\"after:\", l3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if you have a lot of same-value elemets, it will delete just the first one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before: ['ken', 'ben', 'ken', 'ben']\n",
      "after: ['ben', 'ken', 'ben']\n"
     ]
    }
   ],
   "source": [
    "l3 = ['ken','ben','ken','ben']\n",
    "\n",
    "print(\"before:\", l3)\n",
    "\n",
    "l3.remove('ken') # removes the first ken\n",
    "\n",
    "print(\"after:\", l3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### count\n",
    "`count()` counts the number of occurances of a value in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "some_list = [57, 19, 4, 14, 3, 4, 3, 4]\n",
    "\n",
    "print(some_list.count(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing a list\n",
    "Slicing means returning only a *part* of the list. \n",
    "\n",
    "This can be done using ranges:\n",
    "\n",
    "`list[from:to]`\n",
    "\n",
    "This `from` and `to` are indexes of the values. \n",
    "\n",
    ">**Note**: the `to` index is always excluded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['great', 'america', 'was', 'once', 'undiscovered', 'and', 'everybody', 'was', 'oblivious', 'of', 'everything']\n",
      "['great', 'america']\n",
      "['america', 'was', 'once']\n"
     ]
    }
   ],
   "source": [
    "some_random_string = \"great america was once undiscovered and everybody was oblivious of everything\"\n",
    "l4 = some_random_string.split(\" \")\n",
    "\n",
    "print(l4)\n",
    "print(l4[:2])\n",
    "print(l4[1:4])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use **negative indexes** to count from the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['was', 'once', 'undiscovered', 'and', 'everybody', 'was']\n"
     ]
    }
   ],
   "source": [
    "print(l4[2:-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More on Slicing\n",
    "You can get even more stuff if you specify delimiters and so on:\n",
    "\n",
    "`list[from::x]` -> this returns every `x` element in the list starting `from`. Kind of like an AP.\n",
    "\n",
    "You can modify this to `list[from:to:x]`, to limit the range. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['was', 'undiscovered', 'everybody', 'oblivious', 'everything']\n",
      "['america', 'once', 'and', 'was']\n"
     ]
    }
   ],
   "source": [
    "print(l4[2::2]) # from 2nd index, every 2\n",
    "\n",
    "print(l4[1:8:2]) # from 1st index to 8th, every 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### max, min\n",
    "`max()` and `min()` functions return the largest and smallest values respectively **if they contain the same data-type**. That is, the elements must ALL be either `float`, `int`, or `string`.\n",
    "\n",
    "**Note:**\n",
    ">If you give it a `string` list, the largest and smallest will be based on the alphabetical order. That is, smallest will be closer to `a`  and largest will be closer to `z`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "420\n",
      "america\n",
      "trump\n"
     ]
    }
   ],
   "source": [
    "int_list = [1, 4, 69, 420] \n",
    "string_list = [\"bruh\", \"not bruh\", \"america\", \"trump\"]\n",
    "\n",
    "print(min(int_list)) # print smallest: will print 1\n",
    "print(max(int_list)) # print largest: will print 420\n",
    "\n",
    "print(min(string_list)) # print smallest: will print \"america\"\n",
    "print(max(string_list)) # print largest: will print \"trump\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum\n",
    "The `sum()` function is used to find the sum of all the values of a list.\n",
    "\n",
    "**Note:** You cannot do this for lists with `strings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "494\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[54], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28msum\u001b[39m(int_list)) \u001b[38;5;66;03m# sum the values in the previous int_list\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43msum\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstring_list\u001b[49m\u001b[43m)\u001b[49m) \u001b[38;5;66;03m# will return an error\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(sum(int_list)) # sum the values in the previous int_list\n",
    "\n",
    "print(sum(string_list)) # will return an error\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sort\n",
    "`sort()` sorts the list from ascending to descending.\n",
    "For strings, it follows the same alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24, 69, 78, 100]\n"
     ]
    }
   ],
   "source": [
    "unsorted_int = [69, 100, 78, 24]\n",
    "unsorted_int.sort() # this does the sorting\n",
    "\n",
    "print(unsorted_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Duran Duran', 'Goman', 'Roman']\n"
     ]
    }
   ],
   "source": [
    "unsorted_str = ['Goman', 'Roman', 'Duran Duran']\n",
    "unsorted_str.sort()\n",
    "\n",
    "print(unsorted_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Reverse Sort\n",
    "You can use `sort(reverse=True)` or `reverse()` to sort from descending to ascending.\n",
    "\n",
    "Examples for the above lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integers: [100, 78, 69, 24]\n",
      "Strings: ['Roman', 'Goman', 'Duran Duran']\n"
     ]
    }
   ],
   "source": [
    "unsorted_int.sort(reverse=True)\n",
    "print(\"Integers:\", unsorted_int)\n",
    "\n",
    "unsorted_str.sort(reverse=True)\n",
    "print(\"Strings:\", unsorted_str)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[46, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "some_list = [8, 7, 46]\n",
    "\n",
    "some_list.reverse()\n",
    "\n",
    "print(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reverse\n",
    "the `reverse()` function really just reverses the list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 31, 56, 77, 78]\n"
     ]
    }
   ],
   "source": [
    "new_list_to_reverse = [78, 77, 56, 31, 4]\n",
    "\n",
    "new_list_to_reverse.reverse()\n",
    "\n",
    "print(new_list_to_reverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can use [list slicing](#slicing-a-list) to do this without affecting your original list.\n",
    "\n",
    "Just do `list[::-1]`.\n",
    "\n",
    "What this does is get every element from the **end** of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[44, 12, 71, 99, 12]\n"
     ]
    }
   ],
   "source": [
    "another_list = [12, 99, 71, 12, 44]\n",
    "\n",
    "print(another_list[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for Dictionaries\n",
    "These functions are specific for dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### keys and values\n",
    "Using the `keys()` and `values()` functions, we can get *only* the keys or the values from a given dictionary. This essentially returns a list of those values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Werner', 'Niels', 'Enrico'])\n",
      "dict_values(['Heisenberg', 'Bohr', 'Fermi'])\n"
     ]
    }
   ],
   "source": [
    "dict_test = {\n",
    "    \"Werner\":\"Heisenberg\",\n",
    "    \"Niels\":\"Bohr\",\n",
    "    \"Enrico\":\"Fermi\"\n",
    "}\n",
    "\n",
    "print(dict_test.keys())\n",
    "print(dict_test.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overriding Dictionary Values\n",
    "Similar to [lists](#overriding-list-values), one can override a value of a given key in a dict.\n",
    "\n",
    "`dict[\"key\"] = \"new value\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### del\n",
    "Not specific to dictonaries but for whole Python, but you can use `del` to delete a key from a dictionary.\n",
    "\n",
    "Like this:\n",
    "`del dict[\"key\"]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Natasha': 'Romanoff', 'Wanda': 'Maximoff', 'Janet': 'Van Dyne'}\n",
      "{'Natasha': 'Romanoff', 'Janet': 'Van Dyne'}\n"
     ]
    }
   ],
   "source": [
    "some_test_dict = {\n",
    "    \"Natasha\":\"Romanoff\",\n",
    "    \"Wanda\":\"Maximoff\",\n",
    "    \"Janet\":\"Van Dyne\"\n",
    "}\n",
    "\n",
    "print(some_test_dict)\n",
    "del some_test_dict[\"Wanda\"]\n",
    "\n",
    "print(some_test_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Werner': 'Heisenberg', 'Niels': 'Not so Bohr', 'Enrico': 'Fermi'}\n"
     ]
    }
   ],
   "source": [
    "dict_test[\"Niels\"] = \"Not so Bohr\"\n",
    "\n",
    "print(dict_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traversing in a Data Structure\n",
    "Traversing means \"going through\". \n",
    "For data structures, we can traverse through the list and get all the values using **loops**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cab\n",
      "taxi\n",
      "hocus pocus\n"
     ]
    }
   ],
   "source": [
    "list_trav = [\"cab\", \"taxi\", \"hocus pocus\"]\n",
    "\n",
    "for i in list_trav:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "tup_trav = (1, 3, 4)\n",
    "\n",
    "for i in tup_trav:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grave\n",
      "time\n",
      "lol\n",
      "yard\n",
      "stamp\n",
      "lmao\n"
     ]
    }
   ],
   "source": [
    "dict_trav = {\n",
    "    \"grave\":\"yard\",\n",
    "    \"time\":\"stamp\",\n",
    "    \"lol\":\"lmao\"\n",
    "}\n",
    "\n",
    "for i in dict_trav.keys(): # for only the keys, this is essentially a list\n",
    "    print(i)\n",
    "\n",
    "for i in dict_trav.values(): # for only the values\n",
    "    print(i)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}