06-Python-Collection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d9e18675-f9a5-4765-9897-f54999969439",
   "metadata": {},
   "source": [
    "## Python Collections (Arrays)\n",
    "There are four collection data types in the Python programming language:\n",
    "\n",
    "1. **List** is a collection which is ordered and changeable. Allows duplicate members.\n",
    "2. **Tuple** is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "3. **Set** is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
    "4. **Dictionary** is a collection which is ordered** and changeable. No duplicate members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbd19668-fc06-41ab-8984-d915ae099a7d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9d43496d-3b27-4327-a123-ecca9e23a9fc",
   "metadata": {},
   "source": [
    "### Example demonstrating all 4 collection types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17e8f568-e475-4213-ab88-bd803d060a9f",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Python program demonstrating all 4 collection types\n",
    "\n",
    "# 1. List - ordered, changeable, allows duplicates\n",
    "my_list = [\"apple\", \"banana\", \"cherry\", \"apple\"]\n",
    "print(\"List example:\")\n",
    "print(f\"Original list: {my_list}\")\n",
    "my_list.insert(2, \"chia\")\n",
    "my_list.append(\"orange\")  # Lists are changeable\n",
    "print(f\"First item: {my_list[0]}\")  # Lists are ordered (indexed)\n",
    "my_list[3] = \"dates\"\n",
    "print(f\"After adding 'orange': {my_list}\")\n",
    "\n",
    "# 2. Tuple - ordered, unchangeable, allows duplicates\n",
    "my_tuple = (\"apple\", \"banana\", \"cherry\", \"apple\")\n",
    "print(\"Tuple example:\")\n",
    "print(f\"Tuple: {my_tuple}\")\n",
    "print(f\"Second item: {my_tuple[1]}\")  # Tuples are ordered (indexed)\n",
    "# my_tuple[0] = \"orange\"  # This would cause an error - tuples are unchangeable\n",
    "print()\n",
    "\n",
    "# 3. Set - unordered, unchangeable items, no duplicates\n",
    "my_set = {\"apple\", \"banana\", \"cherry\", \"apple\"}  # Note: duplicate \"apple\" will be removed\n",
    "print(\"Set example:\")\n",
    "print(f\"Set: {my_set}\")  # Notice only one \"apple\" appears\n",
    "my_set.add(\"orange\")  # You can add items to a set\n",
    "print(f\"After adding 'orange': {my_set}\")\n",
    "# print(my_set[0])  # This would cause an error - sets are unordered and unindexed\n",
    "print()\n",
    "\n",
    "# 4. Dictionary - ordered, changeable, no duplicate keys\n",
    "my_dict = {\n",
    "    \"name\": \"John\",\n",
    "    \"age\": 30,\n",
    "    \"city\": \"New York\"\n",
    "}\n",
    "print(\"Dictionary example:\")\n",
    "print(f\"Dictionary: {my_dict}\")\n",
    "my_dict[\"email\"] = \"john@example.com\"  # Dictionaries are changeable\n",
    "print(f\"After adding email: {my_dict}\")\n",
    "print(f\"Value of 'name' key: {my_dict['name']}\")  # Access by key"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75bf38a6-8514-4e27-b66c-9919a11dbcf5",
   "metadata": {},
   "source": [
    "## Tuples in Python\n",
    "\n",
    "**What it is:** A tuple is an ordered, immutable collection of items.\n",
    "\n",
    "**Ordered:** The items are stored in a specific sequence, and that sequence will not change. You can access items by their index (e.g., the first item, the second item).\n",
    "**Immutable:** Once a tuple is created, you cannot change its contents. You can't add new items, remove existing items, or change an item at a specific position.\n",
    "Tuples are defined using parentheses ().\n",
    "In what situations will a Data Engineer/Data Analyst use it?\n",
    "\n",
    "**Representing Fixed Collections of Data** When you have a small, fixed set of related items where the order matters and the items shouldn't change.\n",
    "\n",
    "**Examples:**\n",
    "\n",
    "**Data Integrity:** When you want to pass around a collection of items and be absolutely sure they won't be accidentally modified.\n",
    "Example: Defining a set of constant column names that should be used consistently across a script.\n",
    "\n",
    "**Returning Multiple Values from a Function:** Functions in Python can only return a single \"object.\" Tuples are a very common and Pythonic way to return multiple values bundled together.\n",
    "Example: A data processing function might return (number_of_records_processed, number_of_errors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6199c55-5871-46b1-a4cd-b05fb037fec4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7075410c-21af-4240-adb4-57981da3ad47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC Latitude: 40.7128\n",
      "NYC Longitude: -74.006\n",
      "Unpacked - Lat: 40.7128, Lon: -74.006\n",
      "(40.7128, -74.006)\n"
     ]
    }
   ],
   "source": [
    "location_coords = (40.7128, -74.0060) # New York City\n",
    "another_location = (34.0522, -118.2437) # Los Angeles\n",
    "\n",
    "print(f\"NYC Latitude: {location_coords[0]}\")\n",
    "print(f\"NYC Longitude: {location_coords[1]}\")\n",
    "\n",
    "# Attempting to change a value will raise an error\n",
    "#location_coords[0] = 41.0\n",
    "\n",
    "# You can assigning values of tuples to 2 variables\n",
    "lat, lon = location_coords\n",
    "print(f\"Unpacked - Lat: {lat}, Lon: {lon}\")\n",
    "\n",
    "print(location_coords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f33a2bc-d307-4b67-b672-e2572d3a3f7d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5f8063a0-9a5b-453a-ab83-38c369389502",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected column order: ('transaction_id', 'customer_id', 'amount', 'timestamp')\n",
      "The first expected column is: transaction_id\n",
      "Column order mismatch!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "expected_columns = ('transaction_id', 'customer_id', 'amount', 'timestamp')\n",
    "\n",
    "print(f\"Expected column order: {expected_columns}\")\n",
    "print(f\"The first expected column is: {expected_columns[0]}\")\n",
    "\n",
    "# Imagine you receive data and check if its columns match\n",
    "received_columns = ['transaction_id', 'customer_id', 'timestamp', 'amount'] # This is a list\n",
    "\n",
    "if tuple(received_columns) == expected_columns:\n",
    "    print(\"Column order matches the expectation.\")\n",
    "else:\n",
    "    print(\"Column order mismatch!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b4e377c-1f39-4c7b-be8f-1e6965204f6c",
   "metadata": {},
   "source": [
    "## Sets in Python\n",
    "\n",
    "**What is a Set?**\n",
    "A set is an unordered collection of unique items. Think of it like a mathematical set. Key characteristics:\n",
    "\n",
    "**Unordered:** The elements in a set do not have a specific order. You cannot refer to an element by an index number.\n",
    "\n",
    "**Unique:** A set cannot contain duplicate values. If you try to add an element that's already present, the set remains unchanged.\n",
    "\n",
    "**Mutable:** You can add or remove elements from a set after it's created. (Note: The elements within a set must be of an immutable type, like numbers, strings, or tuples).\n",
    "\n",
    "-----------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4d1b0e29-92ca-451b-8099-d197ff187c43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added 4 to set1: {1, 2, 3, 4}\n",
      "Added 6 and 7 to set2: {3, 4, 5, 6, 7}\n",
      "Removed 1 from set1: {2, 3, 4}\n",
      "Discarded 3 from set2: {4, 5, 6, 7}\n",
      "Current Set 1: {2, 3, 4}\n",
      "Current Set 2: {4, 5, 6, 7}\n",
      "Set 1 after clearing: set()\n"
     ]
    }
   ],
   "source": [
    "# A simple example to demonstrate sets\n",
    "\n",
    "# Creating sets\n",
    "set1 = {1, 2, 3}  # Set created using curly braces\n",
    "set2 = set([3, 4, 5])  # Set created from a list\n",
    "\n",
    "# Adding elements\n",
    "set1.add(4)  # Adds the element 4 to set1\n",
    "print(\"Added 4 to set1:\", set1)\n",
    "\n",
    "set2.update([6, 7])  # Adds multiple elements (6 and 7) to set2\n",
    "print(\"Added 6 and 7 to set2:\", set2)\n",
    "\n",
    "# Removing elements\n",
    "set1.remove(1)  # Removes the element 1 from set1 (raises error if not present)\n",
    "print(\"Removed 1 from set1:\", set1)\n",
    "\n",
    "set2.discard(3)  # Removes the element 3 from set2 (does nothing if not present)\n",
    "print(\"Discarded 3 from set2:\", set2)\n",
    "\n",
    "# Printing sets\n",
    "print(\"Current Set 1:\", set1)\n",
    "print(\"Current Set 2:\", set2)\n",
    "\n",
    "# Clearing a set\n",
    "set1.clear()  # Removes all elements from set1\n",
    "print(\"Set 1 after clearing:\", set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0df3d008-c40a-4080-86c2-979f08bd3c8a",
   "metadata": {},
   "source": [
    "## Set Operations\n",
    "\n",
    "**Use Cases for Data Engineers/Data Analysts:**\n",
    "\n",
    "Data engineers and data analysts find sets extremely useful for several common tasks:\n",
    "\n",
    "**De-duplication/Finding Uniqueness:**\n",
    "\n",
    "**Use Case:** Quickly getting a list of unique customer IDs from a transaction log, unique product SKUs, or unique IP addresses from web server logs.\n",
    "Why sets? Their inherent property of storing only unique items makes this trivial. Converting a list to a set and back to a list is a common way to de-duplicate.\n",
    "Membership Testing (Fast Lookups):\n",
    "\n",
    "**Use Case:** Checking if a particular user ID exists in a large list of VIP customers, if a specific product is part of a promotional campaign, or if an encountered error code is in a list of known critical errors.\n",
    "Why sets? Sets are highly optimized for checking if an element is present (in operator). This is significantly faster than searching through a list, especially for large collections.\n",
    "Comparing Collections (Set Operations): This is where sets shine for analytical tasks:\n",
    "\n",
    "**Intersection (finding common elements):**\n",
    "Use Case: \"Which customers bought product A and product B?\" or \"Which users are active on our website and our mobile app?\"\n",
    "                                                          \n",
    "**Union (combining all unique elements):**\n",
    "Use Case: \"Get a list of all unique customers who interacted with marketing campaign X or campaign Y.\"\n",
    "                                                          \n",
    "**Difference (finding elements in one but not the other):**\n",
    "Use Case: \"Which customers made a purchase last month but not this month?\" or \"Which products are in warehouse A but not in warehouse B (data reconciliation)?\"\n",
    "                                                          \n",
    "**Symmetric Difference (finding elements in either, but not both):**\n",
    "Use Case: \"Identify items that are in list A or list B, but not common to both (highlighting discrepancies).\"\n",
    "\n",
    "---\n",
    "\n",
    "### Can Set Operations Be Used with Lists or Tuples?\n",
    "\n",
    "The set operations you mentioned—**intersection, union, difference, and symmetric difference**—are **natively supported only by sets** in Python.\n",
    "\n",
    "---\n",
    "\n",
    "### Why Only Sets?\n",
    "\n",
    "- **Sets** are designed for mathematical set operations.  \n",
    "  - They ensure all elements are unique.\n",
    "  - They provide optimized methods for these operations.\n",
    "- **Lists** and **tuples** can contain duplicates and maintain order, so they do **not** have built-in support for these set operations.\n",
    "\n",
    "---\n",
    "\n",
    "### What About Lists and Tuples?\n",
    "\n",
    "- **Lists** and **tuples** do **not** have methods like `.union()`, `.intersection()`, etc.\n",
    "- If you want to perform set operations on lists or tuples, you need to **convert them to sets first**.\n",
    "\n",
    "> **Example:**  \n",
    "> To find common elements between two lists, convert them to sets and then use set operations.\n",
    "\n",
    "---\n",
    "\n",
    "### Summary Table\n",
    "\n",
    "| Operation           | Sets | Lists | Tuples |\n",
    "|---------------------|:----:|:-----:|:------:|\n",
    "| Intersection        |  ✔️  |   ❌  |   ❌   |\n",
    "| Union               |  ✔️  |   ❌  |   ❌   |\n",
    "| Difference          |  ✔️  |   ❌  |   ❌   |\n",
    "| Symmetric Difference|  ✔️  |   ❌  |   ❌   |\n",
    "\n",
    "---\n",
    "\n",
    "### In Practice\n",
    "\n",
    "- **Use sets** when you need to perform these types of comparisons or analyses.\n",
    "- **Convert lists/tuples to sets** if you need to use set operations, then convert back if you need the result as a list or tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef1ac3f0-5a66-409a-b99b-23018b2c03b0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "93d980ec-07c1-4dff-929c-d4eb7fc575e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of set1 and set2 (all unique elements from both sets): {1, 2, 3, 4, 5}\n",
      "Intersection of set1 and set2 (common in both elements): {3}\n",
      "Difference of set1 and set2 (elements in set1 but not in set2): {1, 2}\n",
      "Symmetric difference of set1 and set2 (elements in either set, but not both): {1, 2, 4, 5}\n",
      "Is 4 in set1? False\n",
      "Elements in set2:\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Creating sets\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "\n",
    "# Set operations\n",
    "# Union combines all unique elements from both sets\n",
    "union_set = set1 | set2\n",
    "print(\"Union of set1 and set2 (all unique elements from both sets):\", union_set)\n",
    "\n",
    "# Intersection finds common elements between sets\n",
    "intersection_set = set1 & set2\n",
    "print(\"Intersection of set1 and set2 (common in both elements):\", intersection_set)\n",
    "\n",
    "# Difference finds elements in set1 but not in set2\n",
    "difference_set = set1 - set2\n",
    "print(\"Difference of set1 and set2 (elements in set1 but not in set2):\", difference_set)\n",
    "\n",
    "# Symmetric difference finds elements in either set, but not in both\n",
    "symmetric_difference_set = set2 ^ set1\n",
    "print(\"Symmetric difference of set1 and set2 (elements in either set, but not both):\", symmetric_difference_set)\n",
    "\n",
    "# Checking for membership\n",
    "print(\"Is 4 in set1?\", 4 in set1)  # Checks if 4 is an element of set1\n",
    "\n",
    "# Iterating through a set\n",
    "print(\"Elements in set2:\")\n",
    "for item in set2:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e9cb965-59bb-4886-b68b-d5cca0a65c79",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0d800b69-fdaa-4dea-8064-639efeedf7b5",
   "metadata": {},
   "source": [
    "## Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebdbc83c-5501-44a0-97e2-e7f91d3236bf",
   "metadata": {},
   "source": [
    "A dictionary is an unordered (in Python versions before 3.7; ordered by insertion in Python 3.7+) collection of key-value pairs.\n",
    "\n",
    "**Key-Value Pairs:** Each item in a dictionary consists of a unique key and its associated value. {'key1': 'value1', 'key2': 'value2'}.\n",
    "Unique Keys: Keys within a dictionary must be unique. If you try to add a key that already exists, its value will be updated.\n",
    "**Immutable Keys:** Keys must be of an immutable type (e.g., strings, numbers, tuples). Values can be of any type (including lists or other dictionaries).\n",
    "**Mutable:** Dictionaries themselves are mutable. You can add, remove, or modify key-value pairs after creation.\n",
    "Fast Lookups: Dictionaries are highly optimized for retrieving a value when you know its key.\n",
    "Dictionaries are defined using curly braces {}.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "578f5a9b-ac6a-4996-baca-aa869f5d291c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "34df206e-49db-4244-a08f-e7bbb87dab6b",
   "metadata": {},
   "source": [
    "**Historically (Python < 3.7):** If you added {'name': 'Alice', 'age': 30, 'city': 'New York'}. When you looped through it, you might get age first, then city, then name, or some other arbitrary order. This order could even change between different runs of the same script or different Python versions (pre-3.7).\n",
    "\n",
    "**Currently (Python 3.7+):** If you add {'name': 'Alice', 'age': 30, 'city': 'New York'}. When you loop through it, you will reliably get name first, then age, then city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39bcce03-6780-4a6c-a866-aaec7889cf75",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "11b4969b-80e7-4906-8dc4-514d3e536458",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Germany': 'Berlin', 'Canada': 'Ottawa', 'England': 'London'}\n"
     ]
    }
   ],
   "source": [
    "# creating a dictionary\n",
    "country_capitals = {\n",
    "  \"Germany\": \"Berlin\", \n",
    "  \"Canada\": \"Ottawa\", \n",
    "  \"England\": \"London\"\n",
    "}\n",
    "\n",
    "# printing the dictionary\n",
    "print(country_capitals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9db6b42c-cdd8-4006-be60-6c2c25f326ef",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {
    "bbc2fd28-0925-434d-82c0-2e904617155a.png": {
     "image/png": "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.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"
    }
   },
   "cell_type": "markdown",
   "id": "775821af-05f2-4b29-9cc8-d46cafde11ff",
   "metadata": {},
   "source": [
    "![image.png](attachment:bbc2fd28-0925-434d-82c0-2e904617155a.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17031d4b-39bd-4b41-9ef4-98d255b0adbc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d742bd1b-a346-4503-9b4a-43a5eb07df19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Berlin\n",
      "London\n"
     ]
    }
   ],
   "source": [
    "country_capitals = {\n",
    "  \"Germany\": \"Berlin\", \n",
    "  \"Canada\": \"Ottawa\", \n",
    "  \"England\": \"London\"\n",
    "}\n",
    "\n",
    "# access the value of keys\n",
    "print(country_capitals[\"Germany\"])\n",
    "print(country_capitals[\"England\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a6c53b7-e209-4ba6-b88d-58232a2ce91e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1cc5ed4f-b367-4ed2-8145-59576ca3fd7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Germany': 'Berlin', 'Canada': 'Ottawa', 'England': 'London', 'Italy': 'Rome'}\n"
     ]
    }
   ],
   "source": [
    "# add an item with \"Italy\" as key and \"Rome\" as its value\n",
    "country_capitals[\"Italy\"] = \"Rome\"\n",
    "\n",
    "print(country_capitals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68e077be-b7a4-493c-a6a3-6eca8e68e3f6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "49c0cf8c-3eeb-4a51-909f-df049c9a0f48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Canada': 'Ottawa', 'England': 'London', 'Italy': 'Rome'}\n"
     ]
    }
   ],
   "source": [
    "# delete item having \"Germany\" key\n",
    "del country_capitals[\"Germany\"]\n",
    "\n",
    "print(country_capitals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "131936e3-902f-4170-b8f0-fd9675b313c1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "742740cc-0bc5-4517-976f-989d9b50a71d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "# clear the dictionary\n",
    "country_capitals.clear()\n",
    "\n",
    "print(country_capitals)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "378bf8f3-41fe-4f55-95b0-622e1189eaad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "826a2a54-98b9-43d4-b39d-abb906dfb983",
   "metadata": {},
   "outputs": [],
   "source": [
    "job_roles = [\n",
    "    {'role': 'Data Engineer - AWS', 'skills': ['Python', 'AWS Glue', 'AWS Lambda', 'S3', 'Redshift', 'SQL', 'Apache Spark']},\n",
    "    {'role': 'Data Engineer - Azure', 'skills': ['Python', 'Azure Data Factory', 'Apache Spark', 'Kubernetes', 'Apache Synapse Analytics', 'SQL', 'Pandas']},\n",
    "    {'role': 'Data Engineer - GCP', 'skills': ['Python', 'Cloud Dataflow', 'Cloud Functions', 'Cloud Storage', 'BigQuery', 'SQL']},\n",
    "    {'role': 'Data Engineer - Batch Processing', 'skills': ['Python', 'Apache Spark', 'Hadoop', 'SQL', 'Java', 'Scala']},\n",
    "    {'role': 'Data Engineer - Cloud Native', 'skills': ['Python', 'Kubernetes', 'Docker', 'Serverless', 'AWS Lambda', 'Azure Data Factory', 'Google Cloud Functions', 'Pandas']},\n",
    "    {'role': 'Data Engineer - Real-time Data', 'skills': ['Python', 'Apache Kafka', 'Apache Flink', 'Spark Streaming', 'SQL', 'NoSQL']},\n",
    "    {'role': 'Data Engineer - Data Warehousing', 'skills': ['SQL', 'ETL Tools', 'Data Modeling', 'Snowflake', 'Redshift', 'Azure Synapse Analytics']},\n",
    "    {'role': 'Data Engineer - Data Lake', 'skills': ['Python', 'Hadoop', 'Spark', 'AWS S3', 'Azure Data Lake Storage', 'Google Cloud Storage']},\n",
    "    {'role': 'Data Engineer - Database', 'skills': ['SQL', 'Database Administration', 'Data Modeling', 'Oracle', 'MySQL', 'PostgreSQL', 'Kubernetes']},\n",
    "    {'role': 'Data Engineer - MLOps', 'skills': ['Python', 'Kubernetes', 'Docker', 'MLflow', 'CI/CD', 'Cloud Platforms (AWS, Azure, GCP)']}\n",
    "]\n",
    "\n",
    "my_skills = ['Azure Data Factory', 'Apache Spark', 'SQL', 'Kubernetes', 'Pandas']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1fe8b974",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(job_roles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "77369f1d-0ed0-4e66-a05b-556626aa0020",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'role': 'Data Engineer - AWS', 'skills': ['Python', 'AWS Glue', 'AWS Lambda', 'S3', 'Redshift', 'SQL', 'Apache Spark']}\n",
      "{'role': 'Data Engineer - Azure', 'skills': ['Python', 'Azure Data Factory', 'Apache Spark', 'Kubernetes', 'Apache Synapse Analytics', 'SQL', 'Pandas']}\n",
      "{'role': 'Data Engineer - GCP', 'skills': ['Python', 'Cloud Dataflow', 'Cloud Functions', 'Cloud Storage', 'BigQuery', 'SQL']}\n",
      "{'role': 'Data Engineer - Batch Processing', 'skills': ['Python', 'Apache Spark', 'Hadoop', 'SQL', 'Java', 'Scala']}\n",
      "{'role': 'Data Engineer - Cloud Native', 'skills': ['Python', 'Kubernetes', 'Docker', 'Serverless', 'AWS Lambda', 'Azure Data Factory', 'Google Cloud Functions', 'Pandas']}\n",
      "{'role': 'Data Engineer - Real-time Data', 'skills': ['Python', 'Apache Kafka', 'Apache Flink', 'Spark Streaming', 'SQL', 'NoSQL']}\n",
      "{'role': 'Data Engineer - Data Warehousing', 'skills': ['SQL', 'ETL Tools', 'Data Modeling', 'Snowflake', 'Redshift', 'Azure Synapse Analytics']}\n",
      "{'role': 'Data Engineer - Data Lake', 'skills': ['Python', 'Hadoop', 'Spark', 'AWS S3', 'Azure Data Lake Storage', 'Google Cloud Storage']}\n",
      "{'role': 'Data Engineer - Database', 'skills': ['SQL', 'Database Administration', 'Data Modeling', 'Oracle', 'MySQL', 'PostgreSQL', 'Kubernetes']}\n",
      "{'role': 'Data Engineer - MLOps', 'skills': ['Python', 'Kubernetes', 'Docker', 'MLflow', 'CI/CD', 'Cloud Platforms (AWS, Azure, GCP)']}\n"
     ]
    }
   ],
   "source": [
    "for job in job_roles:\n",
    "    print(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c24fe11-945d-4297-b2ff-bd3acc1cb919",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6c18cda2-a089-4f00-94db-43a0e21da2dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'AWS Glue', 'AWS Lambda', 'S3', 'Redshift', 'SQL', 'Apache Spark']\n",
      "['Python', 'Azure Data Factory', 'Apache Spark', 'Kubernetes', 'Apache Synapse Analytics', 'SQL', 'Pandas']\n",
      "['Python', 'Cloud Dataflow', 'Cloud Functions', 'Cloud Storage', 'BigQuery', 'SQL']\n",
      "['Python', 'Apache Spark', 'Hadoop', 'SQL', 'Java', 'Scala']\n",
      "['Python', 'Kubernetes', 'Docker', 'Serverless', 'AWS Lambda', 'Azure Data Factory', 'Google Cloud Functions', 'Pandas']\n",
      "['Python', 'Apache Kafka', 'Apache Flink', 'Spark Streaming', 'SQL', 'NoSQL']\n",
      "['SQL', 'ETL Tools', 'Data Modeling', 'Snowflake', 'Redshift', 'Azure Synapse Analytics']\n",
      "['Python', 'Hadoop', 'Spark', 'AWS S3', 'Azure Data Lake Storage', 'Google Cloud Storage']\n",
      "['SQL', 'Database Administration', 'Data Modeling', 'Oracle', 'MySQL', 'PostgreSQL', 'Kubernetes']\n",
      "['Python', 'Kubernetes', 'Docker', 'MLflow', 'CI/CD', 'Cloud Platforms (AWS, Azure, GCP)']\n"
     ]
    }
   ],
   "source": [
    "for job in job_roles:\n",
    "    print(job['skills'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eacc68f4-fb8c-4590-b763-6351b6ccc3e1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "46a332ee-5bd7-49fc-a370-40cb1828167b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Azure Data Factory\n",
      "Apache Spark\n",
      "SQL\n",
      "Kubernetes\n",
      "Pandas\n"
     ]
    }
   ],
   "source": [
    "for skill in my_skills:\n",
    "    print(skill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acc19f9d-3d6f-4bd9-98cd-9dff3135cce1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7381018-9cdf-457c-82ef-329bca8f7023",
   "metadata": {},
   "outputs": [],
   "source": [
    "for job in job_roles:\n",
    "    for skill in my_skills:\n",
    "        print(skill)\n",
    "        print(job['skills'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "293aec2e-7fc2-4af8-90fa-a14ce96a85d3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37ab4180-9b93-434c-843f-8d40e69c491a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for job in job_roles:\n",
    "    for skill in my_skills:\n",
    "        if skill in job['skills']:\n",
    "            print(skill)\n",
    "            print(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4018d31e-9ca5-4812-b216-6057e451ef63",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce916230-9317-42c1-9133-2594ed3658bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "for job in job_roles:\n",
    "    qualified = True\n",
    "    \n",
    "    for skill in my_skills:\n",
    "        if skill in job['skills']:\n",
    "            print(skill)\n",
    "            print(job['skills'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70b86e7a-80e8-483f-aa95-010a949a49a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "82c50145-fc4a-40dd-8ebe-771834880aee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Role: Data Engineer - AWS - Match Percentage: 42.9%\n",
      "\n",
      "Role: Data Engineer - Azure - Match Percentage: 71.4%\n",
      "\n",
      "Role: Data Engineer - GCP - Match Percentage: 33.3%\n",
      "\n",
      "Role: Data Engineer - Batch Processing - Match Percentage: 50.0%\n",
      "\n",
      "Role: Data Engineer - Cloud Native - Match Percentage: 37.5%\n",
      "\n",
      "Role: Data Engineer - Real-time Data - Match Percentage: 33.3%\n",
      "\n",
      "Role: Data Engineer - Data Warehousing - Match Percentage: 16.7%\n",
      "\n",
      "Role: Data Engineer - Data Lake - Match Percentage: 16.7%\n",
      "\n",
      "Role: Data Engineer - Database - Match Percentage: 14.3%\n",
      "\n",
      "Role: Data Engineer - MLOps - Match Percentage: 16.7%\n"
     ]
    }
   ],
   "source": [
    "myskills = ['Azure Data Factory', 'Python', 'SQL', 'Apache Spark', 'Pandas']\n",
    "\n",
    "# Function to calculate skill match percentage\n",
    "def calculate_match(required_skills, my_skills):\n",
    "    matching_skills = set(required_skills) & set(my_skills)\n",
    "    return (len(matching_skills) / len(required_skills)) * 100\n",
    "\n",
    "# Loop through each job role and check skills match\n",
    "for job in job_roles:\n",
    "    matching_skills = set(job['skills']) & set(myskills)\n",
    "    match_percentage = calculate_match(job['skills'], myskills)\n",
    "\n",
    "    print(f\"\\nRole: {job['role']} - Match Percentage: {match_percentage:.1f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f135b09-9a1f-4eda-a8f1-fd008cae5f22",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5509378-9646-4a5b-8cfb-a926e517acdd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67963888-876f-405c-ae6e-e7f264cd71d0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78ce37ef-d0f8-41fb-a39d-3b7a32dc3140",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6199fc3-a571-4983-8484-e6c85de6892a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "477defcf-60e2-4d57-9605-10ad26308afe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b7c53d5-e933-487d-b586-671bdab51049",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52e89292-9b3d-488b-a34e-720b55ed21f0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}