week-2/2-python-data-types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and, or, not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = 1 and 0\n",
    "bool(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(not True and False)\n",
    "print(not (True and False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_number = 10\n",
    "second_number = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is greater than 5\n"
     ]
    }
   ],
   "source": [
    "if first_number > second_number:\n",
    "    print(f\"{first_number} is greater than {second_number}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_number = 10\n",
    "second_number = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is greater than 10\n"
     ]
    }
   ],
   "source": [
    "if first_number > second_number:\n",
    "    print(f\"{first_number} is greater than {second_number}\")\n",
    "else:\n",
    "    print(f\"{second_number} is greater than {first_number}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is equal with 10\n"
     ]
    }
   ],
   "source": [
    "if first_number > second_number:\n",
    "    print(f\"{first_number} is greater than {second_number}\")\n",
    "elif first_number == second_number:\n",
    "    print(f\"{first_number} is equal with {second_number}\")\n",
    "else:\n",
    "    print(f\"{second_number} is greater than {first_number}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_score = 80\n",
    "age = 18\n",
    "# age between 16-18, score 80 or above, intern-driver\n",
    "# age above 18, score score 80 or above, driver\n",
    "# age between 16-18, score 60-80, supervised-intern-driver\n",
    "# age above 18, score score 60-80, supervised-driver\n",
    "\n",
    "def driver_status(age, test_score):\n",
    "    if test_score >= 80:\n",
    "        if 18 > age >= 16:\n",
    "            return \"intern-driver\"\n",
    "        elif age >= 18:\n",
    "            return \"driver\"\n",
    "    elif 80 > test_score >= 60:\n",
    "        if 18 > age >= 16:\n",
    "            return \"supervised-intern-driver\"\n",
    "        elif age >= 18:\n",
    "            return \"supervised-driver\"\n",
    "    return \"Unlicenced\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'driver'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "driver_status(age, test_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buzz_func(number):\n",
    "    return \"Buzz!\" if number % 2 == 0 else str(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_number = 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buzz_func(my_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_string = \"Ada Lovelace Academy had started!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ada lovelace academy had started!'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ada Lovelace Academy had started'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_string.strip(\"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_string.endswith('!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ada Lovelace Academy had started.'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_string.replace('!', '.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ada Lovelace Academy had started!\n"
     ]
    }
   ],
   "source": [
    "print(test_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15 != 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ada\" == \"Lovelace\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:1: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "<>:1: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "/tmp/ipykernel_7304/4010171800.py:1: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "  15 is not my_number\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15 is not my_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3]\n",
    "print(3 not in my_list)\n",
    "print(1 in my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "empty_list = []\n",
    "print(empty_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'string', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "example_list = [1, \"string\", [1, 2, 3]]\n",
    "print(example_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "test_list = list()\n",
    "print(test_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['s', 't', 'r', 'i', 'n', 'g']\n",
      "['string']\n"
     ]
    }
   ],
   "source": [
    "example_list = list(\"string\")\n",
    "literal_list = [\"string\"]\n",
    "print(example_list)\n",
    "print(literal_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_list = [1, \"academy\", [1, 2, 3]]\n",
    "example_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'academy']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_list[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yellow\n",
      "green\n",
      "red\n",
      "blue\n",
      "purple\n"
     ]
    }
   ],
   "source": [
    "colors = [\"yellow\", \"green\", \"red\", \"blue\", \"purple\"]\n",
    "\n",
    "for color in colors:\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: yellow\n",
      "1: green\n",
      "2: red\n",
      "3: blue\n",
      "4: purple\n"
     ]
    }
   ],
   "source": [
    "for index, color in enumerate(colors):\n",
    "    print(f\"{index}: {color}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cubes_to_1000 = []\n",
    "\n",
    "# range(10)\n",
    "# <list>.append(<item>)\n",
    "\n",
    "for number in range(1, 11):\n",
    "    cubes_to_1000.append(number**3)\n",
    "\n",
    "cubes_to_1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple']\n"
     ]
    }
   ],
   "source": [
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple']\n"
     ]
    }
   ],
   "source": [
    "new_colors = colors\n",
    "print(new_colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple', 'orange']\n"
     ]
    }
   ],
   "source": [
    "new_colors.append(\"orange\")\n",
    "print(new_colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple', 'orange']\n"
     ]
    }
   ],
   "source": [
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'orange'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple']\n"
     ]
    }
   ],
   "source": [
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple']\n"
     ]
    }
   ],
   "source": [
    "newest_colors = colors.copy()\n",
    "print(newest_colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "newest_colors.append(\"black\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yellow', 'green', 'red', 'blue', 'purple', 'black']\n",
      "['yellow', 'green', 'red', 'blue', 'purple']\n"
     ]
    }
   ],
   "source": [
    "print(newest_colors)\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "newest_colors.insert(0, \"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gray', 'yellow', 'green', 'red', 'blue', 'purple', 'black']\n"
     ]
    }
   ],
   "source": [
    "print(newest_colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extend, add two list together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "newest_colors.remove('yellow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m/home/varfo/Projects/data-science/2-python-data-types.ipynb Cell 54\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/varfo/Projects/data-science/2-python-data-types.ipynb#Y115sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m newest_colors\u001b[39m.\u001b[39;49mremove(\u001b[39m'\u001b[39;49m\u001b[39mcyan\u001b[39;49m\u001b[39m'\u001b[39;49m)\n",
      "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "newest_colors.remove('cyan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['yellow', 'red', 'purple', 'green', 'blue']"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors = [\"yellow\", \"green\", \"red\", \"blue\", \"purple\"]\n",
    "colors.sort(reverse=True)\n",
    "colors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors.index(\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples & Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = tuple()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = tuple([10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('L', 'o', 'v', 'e', 'l', 'a', 'c', 'e')\n"
     ]
    }
   ],
   "source": [
    "my_tuple = tuple(\"Lovelace\")\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 'Ada', 'Lovelace', 11)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = tuple([10, \"Ada\", \"Lovelace\", 11])\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary\n",
    "animal_colors = {\n",
    "    \"cat\": \"yellow\",\n",
    "    \"dog\": \"black\",\n",
    "    \"horse\": \"brown\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('cat', 'dog', 'horse')\n"
     ]
    }
   ],
   "source": [
    "animal_colors_tuple = tuple(animal_colors)\n",
    "print(animal_colors_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('cat', 'yellow'), ('dog', 'black'), ('horse', 'brown'))\n"
     ]
    }
   ],
   "source": [
    "animal_colors_tuple_2 = tuple(animal_colors.items())\n",
    "print(animal_colors_tuple_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "my_new_tuple = (\"ada\",)\n",
    "print(type(my_new_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('ada', 'lovelace')\n"
     ]
    }
   ],
   "source": [
    "my_new_tuple = \"ada\", \"lovelace\"\n",
    "print(my_new_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ada'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_new_tuple[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cat': 'yellow', 'dog': 'black', 'horse': 'brown'}\n"
     ]
    }
   ],
   "source": [
    "animals = dict([('cat', 'yellow'), ('dog', 'black'), ('horse', 'brown')])\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary\n",
    "animals = {\n",
    "    \"cat\": {\n",
    "        \"color\": \"yellow\",\n",
    "        \"weight\": \"5.1\"\n",
    "    },\n",
    "    \"dog\": \"black\",\n",
    "    \"horse\": \"brown\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'black'"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[\"dog\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'dolphin'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m/home/varfo/Projects/data-science/2-python-data-types.ipynb Cell 73\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/varfo/Projects/data-science/2-python-data-types.ipynb#Y144sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m animals[\u001b[39m\"\u001b[39;49m\u001b[39mdolphin\u001b[39;49m\u001b[39m\"\u001b[39;49m]\n",
      "\u001b[0;31mKeyError\u001b[0m: 'dolphin'"
     ]
    }
   ],
   "source": [
    "animals[\"dolphin\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yellow'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[\"cat\"][\"color\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'color': 'yellow', 'weight': '5.1'}"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.get(\"cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals.get(\"bear\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals[\"bear\"] = \"brown\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cat': {'color': 'yellow', 'weight': '5.1'}, 'dog': 'black', 'horse': 'brown', 'bear': 'brown'}\n"
     ]
    }
   ],
   "source": [
    "print(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'brown'"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.pop(\"horse\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "animal_colors = {\n",
    "    \"cat\": \"yellow\",\n",
    "    \"dog\": \"black\",\n",
    "    \"horse\": \"brown\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat is yellow\n",
      "dog is black\n",
      "horse is brown\n"
     ]
    }
   ],
   "source": [
    "for animal, color in animal_colors.items():\n",
    "    print(f\"{animal} is {color}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sets are mutable\n",
    "# frozensets are immutable\n",
    "\n",
    "# iteration\n",
    "# membership (in, not in)\n",
    "# len()\n",
    "# copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## sets do not support!:\n",
    "### indexing\n",
    "### ordering, sorting\n",
    "### slicing\n",
    "### concat +"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {\"ada\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{'ada'}\n"
     ]
    }
   ],
   "source": [
    "print(type(my_set))\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'albert', 'ada', 'marry', 'lovelace'}\n"
     ]
    }
   ],
   "source": [
    "my_set = {\"ada\", \"lovelace\", \"marry\", \"albert\", \"ada\"}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'yellow', 'brown', 'black'}\n"
     ]
    }
   ],
   "source": [
    "animal_colors = {\n",
    "    \"cat\": \"yellow\",\n",
    "    \"dog\": \"black\",\n",
    "    \"horse\": \"brown\",\n",
    "    \"bear\": \"brown\"\n",
    "}\n",
    "\n",
    "animal_set = set(animal_colors.values())\n",
    "print(animal_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 1, 1, 2, 2, 2, 3, 4, 4, 5, 15]\n",
    "\n",
    "calculated_numbers_set = {number**2 for number in numbers if number % 3 == 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{9, 225}\n"
     ]
    }
   ],
   "source": [
    "print(calculated_numbers_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculated_numbers_list = [number**2 for number in numbers if number % 3 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 225]\n"
     ]
    }
   ],
   "source": [
    "print(calculated_numbers_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_numbers(my_number):\n",
    "    my_list = []\n",
    "    for number in numbers:\n",
    "        value = number**2\n",
    "        if value % 3 == 0:\n",
    "            my_list.append(value)         \n",
    "    return set(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{9, 225}\n"
     ]
    }
   ],
   "source": [
    "print(calculate_numbers(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "elements_string = set(\"lovelace\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'o', 'v', 'e', 'l', 'c', 'a'}\n"
     ]
    }
   ],
   "source": [
    "print(elements_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "birds = {'crow','sparrow','eagle','chicken', 'albatross'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = {'chicken': 'white',\n",
    "           'sparrow': 'grey',\n",
    "           'eagle': 'brown and white',\n",
    "           'albatross': 'grey and white',\n",
    "           'crow': 'black',\n",
    "           'elephant': 'grey', \n",
    "           'dog': 'rust',\n",
    "           'cow': 'black and white',\n",
    "           'tiger': 'orange and black',\n",
    "           'cat': 'grey',\n",
    "           'squirrel': 'black'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birds.isdisjoint(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birds.issubset(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(animals).issuperset(birds)"
   ]
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}