3) data structures.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2d0359bf",
   "metadata": {},
   "source": [
    "# Data Structures"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cc61a7fd",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7f7b124a",
   "metadata": {},
   "source": [
    "- Lists, and the other data structures, can contain values of different data types, and that includes also sequence types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "124dfa4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['list', 'of', 'strings']\n",
      "[1, 'list', False, []]\n",
      "[[1, 2, 3], (False, True), range(0, 5)]\n"
     ]
    }
   ],
   "source": [
    "first_list = [1,2,3,4]\n",
    "second_list = ['list', 'of', 'strings']\n",
    "third_list = [1,'list', False, []]\n",
    "fourth_list = [[1,2,3],(False, True), range(5)]\n",
    "\n",
    "print(first_list)\n",
    "print(second_list)\n",
    "print(third_list)\n",
    "print(fourth_list)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2ceb1a22",
   "metadata": {},
   "source": [
    "- To see the **number of items** in a list, use the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "343cab68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(first_list))\n",
    "print(len(fourth_list))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7e80f12a",
   "metadata": {},
   "source": [
    "- **Order** of items **matters**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "38818fb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] == [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "570adeb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] == [1,3,2]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "22d5023a",
   "metadata": {},
   "source": [
    "- Lists are **mutable**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9aa27411",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "first_list.append(5)\n",
    "print(first_list)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2d54cd5f",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "abafc18e",
   "metadata": {},
   "source": [
    "- Are declared with parenthesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f8d946cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple = (1,2,3)\n",
    "len(my_tuple)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d289e756",
   "metadata": {},
   "source": [
    "- Order matters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0b11e898",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,2) == (2,1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "52de31e3",
   "metadata": {},
   "source": [
    "- Unlike lists, tuples are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3fc754a7",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[9], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m my_tuple\u001b[39m.\u001b[39;49mappend(\u001b[39m4\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "my_tuple.append(4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5d6ebc06",
   "metadata": {},
   "source": [
    "- Tuples are **memory efficient**. If you're using lists, the computer will know that the size of the list might change and so it will preallocated more memory for it. \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fe9bdfd8",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "16fcdcd0",
   "metadata": {},
   "source": [
    "- Almost identical to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2cd42f05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_set = {1,2,3,4,5}\n",
    "\n",
    "print(first_set)\n",
    "len(first_set)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ace25fcf",
   "metadata": {},
   "source": [
    "- Except that all of the elements in it have to be unique. Duplicates are ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ce2034e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_set = {1,1,2,2}\n",
    "\n",
    "print(second_set)\n",
    "len(second_set)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "797301b5",
   "metadata": {},
   "source": [
    "- Also, the order of items matters in a list, but not in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "04796b0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # order matters in a list, so this will evaluate to false\n",
    "[1,2] == [2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "eadfbe2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# order doesn't matter in a set, and remember dulicates are ignored, so this will evaluate to true\n",
    "{1,2,3} == {3,2,1,1,1} "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "491e40c6",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2a101900",
   "metadata": {},
   "source": [
    "- Sequence of **key-value** pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "07eacb6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A red fruit'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dictionary = {\n",
    "    'apple': 'A red fruit', \n",
    "    'bear': 'A scary animal'\n",
    "}\n",
    "\n",
    "my_dictionary['apple']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f720876c",
   "metadata": {},
   "source": [
    "- Order doesn't matter."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bc54f63d",
   "metadata": {},
   "source": [
    "- Different data types allowed."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2a838a7e",
   "metadata": {},
   "source": [
    "- The keys in dictionaries have to be unique. In the code snippet below, the last definition for `apple` will be the one taken. All the others before it will be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "40a2a490",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sometimes a green fruit\n",
      "four\n",
      "5 is greater than 4\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "my_dictionary = {\n",
    "    'apple': 'A red fruit', \n",
    "    'bear': 'A scary animal',\n",
    "    'apple': 'Sometimes a green fruit',\n",
    "    4 : 'four',\n",
    "    True: '5 is greater than 4',\n",
    "    '5 is less than 4': False\n",
    "    }\n",
    "\n",
    "print(my_dictionary['apple'])\n",
    "print(my_dictionary[4])\n",
    "print(my_dictionary[True])\n",
    "print(my_dictionary['5 is less than 4'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b6f9fcd8",
   "metadata": {},
   "source": [
    "## Dictionary mapping"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "01c5f9f7",
   "metadata": {},
   "source": [
    "- Use the `get()` method to get the value of a key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "28a8b1d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sometimes a green fruit'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dictionary.get(\"apple\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2b129ecb",
   "metadata": {},
   "source": [
    "- You can also specify a default value to be returned with `get()` when a key is not in the dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d1c42d23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One of my favorite foods'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dictionary.get(\"pancakes\", \"One of my favorite foods\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1d1803f9",
   "metadata": {},
   "source": [
    "- This can be useful in the sort of a `match-case` scenario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a15f1fca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting the program\n"
     ]
    }
   ],
   "source": [
    "command = input(\"Enter a command: \")\n",
    "match command:\n",
    "    case \"start\":\n",
    "        print(\"Starting the program\")\n",
    "    case \"stop\":\n",
    "        print(\"Stopping the program\")\n",
    "    case \"help\":\n",
    "        print(\"Showing the help menu\")\n",
    "    case _:\n",
    "        print(\"Invalid command\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "92b28113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting the program\n",
      "\n",
      "Invalid command\n"
     ]
    }
   ],
   "source": [
    "def switch(input):\n",
    "\n",
    "    command = {\"start\": \"Starting the program\",\n",
    "            \"stop\": \"Stopping the program\",\n",
    "            \"help\": \"Showing the help menu\"}\n",
    "\n",
    "    return command.get(input, \"Invalid command\")\n",
    "\n",
    "print(switch(\"start\"))\n",
    "print()\n",
    "print(switch(\"pause\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d45948b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}