{"title":"Set Operations","description":"","content":"Sets earn their keep the moment you need to combine, compare, or contrast two groups of items: customers in two marketing campaigns, tags on two products, categories across two orders. This lesson covers the four core algebra operations on sets (union, intersection, difference, symmetric difference) along with the subset, superset, and disjoint checks. Each operation comes in two flavors: an operator form and a method form. They look similar but differ in one important way that trips up most beginners.\n\n---\n\n# Union: Combining Two Sets\n\nThe union of two sets contains every element from either set, with no duplicates. The operator form is `|` and the method form is `.union()`.\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = {\"bob\", \"dave\", \"eve\"}\n\nreached = campaign_email | campaign_sms\nprint(reached)\n```\n\n\nEvery customer who saw either campaign appears once in `reached`. `\"bob\"` is in both campaigns but only shows up once, because sets don't keep duplicates. The order in the printed output isn't guaranteed: sets don't track insertion order, so you might see the names in a different sequence on your machine.\n\nIn set-builder language, `a | b` is \"everything that's in `a`, or in `b`, or in both\". You'll sometimes see this written as `a ∪ b` in math notation.\n\nThe method form does the same job but accepts any iterable, not just a set:\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = [\"bob\", \"dave\", \"eve\"]\n\nreached = campaign_email.union(campaign_sms)\nprint(reached)\n```\n\n\n`campaign_sms` here is a list, not a set, and the method handles it fine. The operator version would have raised `TypeError` because `|` requires both operands to be sets. This difference matters often enough that it's worth flagging now: **operators need sets on both sides; methods accept any iterable**. We'll see the same pattern with intersection, difference, and symmetric difference.\n\nThe method also takes multiple iterables at once, which is handy when you have more than two groups to combine:\n\n\n```python\ncampaign_email = {\"alice\", \"bob\"}\ncampaign_sms = {\"carol\", \"dave\"}\ncampaign_push = {\"eve\", \"frank\"}\n\nreached = campaign_email.union(campaign_sms, campaign_push)\nprint(reached)\n```\n\n\nYou can chain the operator too (`a | b | c | d`), but if any operand is a non-set iterable, only the method form works.\n\nNeither form mutates the original sets. `a | b` and `a.union(b)` both return a new set; `a` and `b` are untouched.\n\n\n> **INFO**\n>\n> **Cost:** Union runs in roughly O(len(a) + len(b)). Python walks every element of both sets and inserts it into the result, and each insert is O(1) on average.\n\n\nThe corresponding in-place version is `|=`, which adds every element of the right side into the left set:\n\n\n```python\nreached = {\"alice\", \"bob\"}\nnew_signups = {\"carol\", \"dave\"}\n\nreached |= new_signups\nprint(reached)\n```\n\n\n`|=` mutates the left set in place and returns nothing useful. The equivalent named method is `update()`.\n\n---\n\n# Intersection: Common Elements\n\nThe intersection of two sets contains only the elements that appear in both. The operator form is `&` and the method form is `.intersection()`.\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = {\"bob\", \"carol\", \"dave\"}\n\nboth = campaign_email & campaign_sms\nprint(both)\n```\n\n\n`\"bob\"` and `\"carol\"` are the only customers who saw both campaigns. `\"alice\"` saw only the email, and `\"dave\"` saw only the SMS, so neither is in the result.\n\nIn set-builder language, `a & b` is \"everything that's in `a` and also in `b`\". The math notation is `a ∩ b`.\n\nA Venn-style diagram makes the regions easy to picture:\n\n\n```mermaid\nflowchart LR\n A[\"a only
alice\"]:::cyan\n BOTH[\"a and b
bob, carol\"]:::green\n B[\"b only
dave\"]:::orange\n\n A --- BOTH\n BOTH --- B\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe center region is what `&` returns: the overlap. The two outer regions are what union picks up alongside the center.\n\nThe method form is `intersection`, and like `union` it accepts any iterable:\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = [\"bob\", \"carol\", \"dave\"]\n\nboth = campaign_email.intersection(campaign_sms)\nprint(both)\n```\n\n\nThe same operator-vs-method rule applies: `&` insists on sets, `intersection` accepts a list, tuple, or any other iterable.\n\nYou can also intersect more than two groups at once. The result is the elements common to all of them:\n\n\n```python\npremium_users = {\"alice\", \"bob\", \"carol\", \"dave\"}\nrecent_buyers = {\"bob\", \"carol\", \"eve\"}\nnewsletter_subs = {\"carol\", \"dave\", \"eve\"}\n\ntarget = premium_users & recent_buyers & newsletter_subs\nprint(target)\n```\n\n\nOnly `\"carol\"` appears in all three groups. As soon as one set excludes someone, they drop out of the result.\n\n\n> **INFO**\n>\n> **Cost:** Intersection is roughly O(len(smaller) + len(larger)) on average, because Python iterates the smaller set and checks each element against the larger one in O(1) per check. Sizes matter: scanning a 10-element set against a million-element set is much cheaper than the reverse.\n\n\nNeither `&` nor `intersection` mutates the original sets. The in-place version `&=` keeps only the elements that are also in the right side and discards the rest from the left set.\n\n---\n\n# Difference: In One but Not the Other\n\nThe difference `a - b` contains the elements that are in `a` but not in `b`. The method form is `.difference()`.\n\n\n```python\nall_customers = {\"alice\", \"bob\", \"carol\", \"dave\"}\nchurned = {\"bob\", \"dave\"}\n\nactive = all_customers - churned\nprint(active)\n```\n\n\n`\"bob\"` and `\"dave\"` are removed because they appear in `churned`. `\"alice\"` and `\"carol\"` are kept because they don't.\n\nDifference is the one operation in this lesson where order matters. `a - b` and `b - a` answer different questions:\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = {\"bob\", \"carol\", \"dave\"}\n\nonly_email = campaign_email - campaign_sms\nonly_sms = campaign_sms - campaign_email\n\nprint(only_email)\nprint(only_sms)\n```\n\n\n`only_email` is \"people who saw the email but not the SMS\"; `only_sms` is \"people who saw the SMS but not the email\". Both are useful, but they answer different business questions, so you need to be deliberate about which side goes on the left.\n\nIn set-builder terms, `a - b` is \"everything in `a` that is not in `b`\". The math notation is `a \\ b` or `a − b`.\n\nThe method form accepts any iterable, like the others:\n\n\n```python\ncatalog_tags = {\"sale\", \"new\", \"popular\", \"limited\"}\ndeprecated_tags = [\"limited\", \"discontinued\"]\n\nactive_tags = catalog_tags.difference(deprecated_tags)\nprint(active_tags)\n```\n\n\n`\"limited\"` was in `catalog_tags` and shows up in the iterable, so it's removed. `\"discontinued\"` is in the iterable but not in `catalog_tags`, so it's quietly ignored: difference only removes elements that are actually present.\n\nYou can pass multiple iterables to `difference`, and every element in any of them is removed from the left side:\n\n\n```python\ncandidate_pool = {\"alice\", \"bob\", \"carol\", \"dave\", \"eve\"}\nalready_contacted = {\"bob\"}\nopted_out = {\"dave\", \"eve\"}\n\navailable = candidate_pool.difference(already_contacted, opted_out)\nprint(available)\n```\n\n\n`\"bob\"` is removed because of `already_contacted`. `\"dave\"` and `\"eve\"` are removed because of `opted_out`. The two iterables are effectively unioned together internally before being subtracted from the left.\n\n\n> **INFO**\n>\n> **Cost:** Difference is roughly O(len(a)) on average. Python walks every element of `a` and asks the right-hand operand \"do you contain this?\", which is O(1) per check.\n\n\n---\n\n# Symmetric Difference: In Either but Not Both\n\nThe symmetric difference `a ^ b` contains the elements that are in exactly one of the two sets. Anything in both is removed. The method form is `.symmetric_difference()`.\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = {\"bob\", \"carol\", \"dave\"}\n\nreached_one_only = campaign_email ^ campaign_sms\nprint(reached_one_only)\n```\n\n\n`\"alice\"` saw only the email and `\"dave\"` saw only the SMS, so both appear in the result. `\"bob\"` and `\"carol\"` saw both campaigns, so they are excluded.\n\nYou can think of it as the union minus the intersection. The diagram for symmetric difference is the two outer regions of the Venn diagram, with the overlap left out:\n\n\n```mermaid\nflowchart LR\n LEFT[\"a only
alice\"]:::cyan\n MID[\"a and b
excluded\"]:::red\n RIGHT[\"b only
dave\"]:::orange\n\n LEFT --- MID\n MID --- RIGHT\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe middle region is shown in red to mark that it's dropped from the result. Only the two outer regions are kept.\n\nIn set-builder language, `a ^ b` is \"everything in `a` or `b` but not in both\". A useful identity is `a ^ b == (a | b) - (a & b)`, although Python computes it more directly than that.\n\nUnlike difference, symmetric difference is symmetric: swapping the operands gives the same answer.\n\n\n```python\ncampaign_email = {\"alice\", \"bob\", \"carol\"}\ncampaign_sms = {\"bob\", \"carol\", \"dave\"}\n\nprint(campaign_email ^ campaign_sms)\nprint(campaign_sms ^ campaign_email)\n```\n\n\nThat's expected: \"in exactly one\" is a question about the two sets together, not about which side you're starting from.\n\nThe method form accepts any iterable and otherwise behaves the same way:\n\n\n```python\nnew_orders = {101, 102, 103}\nyesterday_orders = [102, 103, 104]\n\nchanged = new_orders.symmetric_difference(yesterday_orders)\nprint(changed)\n```\n\n\n`101` was added today, `104` was completed yesterday but not in today's snapshot, and `102` and `103` are in both so they drop out. Symmetric difference is a clean way to ask \"what changed between two snapshots?\" when the order doesn't matter.\n\nUnlike `union`, `intersection`, and `difference`, the `symmetric_difference` method only takes **one** iterable. There's no built-in way to chain it across many sets in a single call, because the multi-way version isn't a standard set operation.\n\n\n> **INFO**\n>\n> **Cost:** Symmetric difference is roughly O(len(a) + len(b)). Python has to look at every element on both sides to decide whether it belongs in the result.\n\n\n---\n\n# Operator vs Method: The One Rule to Remember\n\nWe've seen the same pattern four times. Here's the difference in one table:\n\n\n| Operation | Operator | Method | Accepts non-set iterable? |\n| -------------------- | -------- | ---------------------------- | ------------------------- |\n| Union | `a | b` | `a.union(b, ...)` | Method: yes. Operator: no. |\n| Intersection | `a & b` | `a.intersection(b, ...)` | Method: yes. Operator: no. |\n| Difference | `a - b` | `a.difference(b, ...)` | Method: yes. Operator: no. |\n| Symmetric difference | `a ^ b` | `a.symmetric_difference(b)` | Method: yes. Operator: no. |\n\n\nThe operator form is shorter and reads well when both operands are already sets. The method form is what you reach for when one side is a list, tuple, or other iterable, and you don't want to wrap it in `set(...)` first.\n\nWhat happens when you try to use an operator with a non-set iterable? You get a clear error:\n\n\n```python\ntags = {\"sale\", \"new\"}\nincoming = [\"sale\", \"limited\"]\n\nprint(tags | incoming)\n```\n\n\nThe fix is either to convert: `tags | set(incoming)`, or to use the method form: `tags.union(incoming)`. The method form is usually nicer because it skips the extra allocation.\n\n---\n\n# Subset, Superset, and Proper Variants\n\nThe relational operators on sets compare two sets as wholes rather than producing a new set. They answer questions like \"is every element of `a` also in `b`?\".\n\n`a <= b` is true when `a` is a **subset** of `b`: every element of `a` is also in `b`. The method form is `a.issubset(b)`.\n\n\n```python\nfree_users = {\"alice\", \"bob\"}\nall_users = {\"alice\", \"bob\", \"carol\", \"dave\"}\n\nprint(free_users <= all_users)\nprint(free_users.issubset(all_users))\n```\n\n\nEvery name in `free_users` shows up in `all_users`, so `free_users` is a subset.\n\n`a >= b` is the reverse: `a` is a **superset** of `b`, meaning every element of `b` is also in `a`. The method form is `a.issuperset(b)`.\n\n\n```python\nall_users = {\"alice\", \"bob\", \"carol\", \"dave\"}\nfree_users = {\"alice\", \"bob\"}\n\nprint(all_users >= free_users)\nprint(all_users.issuperset(free_users))\n```\n\n\nSame situation, just viewed from the other side. Subset and superset are mirror images: `a <= b` is exactly the same as `b >= a`.\n\nThe strict (or **proper**) variants are `<` and `>`. They require the same containment as `<=` and `>=` but also forbid equality.\n\n\n```python\na = {1, 2, 3}\nb = {1, 2, 3}\nc = {1, 2, 3, 4}\n\nprint(a <= b)\nprint(a < b)\nprint(a < c)\n```\n\n\n`a <= b` is `True` because the two sets are equal (every element of `a` is in `b`, even if `b` adds nothing extra). `a < b` is `False` because the two sets are equal, and \"proper subset\" rules that out. `a < c` is `True` because every element of `a` is in `c` and `c` has at least one extra element.\n\nThere's no method form for `<` and `>`. If you need the proper-subset check, use the operator: `a < b` is the standard way to say \"subset and not equal\".\n\nThe same operator-vs-method rule we saw with the algebra operations also applies here: the methods `issubset` and `issuperset` accept any iterable, but the operators require sets on both sides.\n\n\n```python\nfree_users = {\"alice\", \"bob\"}\nall_users_list = [\"alice\", \"bob\", \"carol\", \"dave\"]\n\nprint(free_users.issubset(all_users_list))\n# print(free_users <= all_users_list) # TypeError\n```\n\n\nThe method handles the list fine. The commented-out operator version would raise the same `TypeError` we saw earlier.\n\nA useful identity: `a == b` is equivalent to `a <= b and b <= a`. Two sets are equal exactly when each is a subset of the other.\n\n---\n\n# Disjoint: No Common Elements\n\nTwo sets are **disjoint** if they share no elements. The check is a method, not an operator: `a.isdisjoint(b)`.\n\n\n```python\nfree_users = {\"alice\", \"bob\"}\nenterprise_users = {\"carol\", \"dave\"}\n\nprint(free_users.isdisjoint(enterprise_users))\n```\n\n\nNo name appears in both groups, so the two sets are disjoint and the method returns `True`.\n\nIf even one element overlaps, the answer flips to `False`:\n\n\n```python\nfree_users = {\"alice\", \"bob\"}\nbeta_testers = {\"bob\", \"eve\"}\n\nprint(free_users.isdisjoint(beta_testers))\n```\n\n\n`\"bob\"` is in both groups, so the sets aren't disjoint.\n\nYou could express the same check with intersection: \"disjoint\" is just \"the intersection is empty\", and `not (a & b)` produces the same boolean. `isdisjoint` is preferred for two reasons. First, it reads as the question you're actually asking. Second, it can short-circuit: as soon as it finds the first shared element, it returns `False` without scanning the rest. Computing `a & b` always walks both sets fully even when you only care whether the result is empty.\n\n\n```python\nbig_a = set(range(1_000_000))\nbig_b = {0, \"anything else\"}\n\n# isdisjoint stops as soon as it finds 0 in both sides\nprint(big_a.isdisjoint(big_b))\n\n# This still works but builds the entire intersection first\nprint(not (big_a & big_b))\n```\n\n\nFor large sets where you expect overlap to be common, the short-circuit can matter. For small sets it makes no practical difference, but `isdisjoint` still reads better.\n\nLike the other methods, `isdisjoint` accepts any iterable:\n\n\n```python\ntags = {\"sale\", \"new\", \"popular\"}\nforbidden = [\"restricted\", \"private\"]\n\nprint(tags.isdisjoint(forbidden))\n```\n\n\nNo tag from `forbidden` appears in `tags`, so the answer is `True`. There's no equivalent operator form.\n\n\n> **INFO**\n>\n> **Cost:** `a.isdisjoint(b)` is at worst O(len(smaller)) on average, but it often returns much faster because it short-circuits on the first shared element.\n\n\n---\n\n# A Worked Example\n\nPutting the operations together on a single scenario makes the differences click. Suppose an online store ran two marketing campaigns last month:\n\n\n```python\nemail_clicks = {\"alice\", \"bob\", \"carol\", \"dave\"}\nsms_clicks = {\"carol\", \"dave\", \"eve\", \"frank\"}\n\n# Everyone who clicked on at least one campaign\nany_click = email_clicks | sms_clicks\n\n# Everyone who clicked on both campaigns\nboth_clicks = email_clicks & sms_clicks\n\n# Clicked on email only\nemail_only = email_clicks - sms_clicks\n\n# Clicked on SMS only\nsms_only = sms_clicks - email_clicks\n\n# Clicked on exactly one (email only OR SMS only)\nexactly_one = email_clicks ^ sms_clicks\n\nprint(\"any:\", any_click)\nprint(\"both:\", both_clicks)\nprint(\"email only:\", email_only)\nprint(\"sms only:\", sms_only)\nprint(\"exactly one:\", exactly_one)\n```\n\n\nEach operation answers a different real question about the same two groups. Union is the total reach. Intersection is the most engaged segment, since these people responded to both channels. Difference splits the audience by channel exclusivity. Symmetric difference is the single-touch group, which often deserves a different follow-up than the dual-touch group.\n\nA check at the end: `exactly_one` equals `email_only | sms_only`, which is also `any_click - both_clicks`. Several routes lead to the same answer, and which one reads best depends on which intermediate result you want to name.","pageType":"python"}

Set Operations

Get Premium