Set Method .union() in Python 2026 with Efficient Code

Set Method .union() in Python 2026 with Efficient Code

The .union() method (and its operator |) is the most efficient way to combine multiple sets while removing duplicates. In 2026, using set union operations is a fundamental best practice for fast and clean data merging in Python.

This March 15, 2026 guide shows how to use .union() and the | operator effectively for high-performance code.

TL;DR — Key Takeaways 2026

• set1.union(set2) or set1 | set2 returns all unique elements from both sets
• Extremely fast due to hash table implementation
• Supports multiple sets in one call: set1.union(set2, set3, ...)
• The | operator is more readable and preferred for simple cases
• Returns a new set — original sets are not modified

1. Basic Usage

set1 = {"apple", "banana", "cherry"}
set2 = {"banana", "date", "elderberry"}

# Two equivalent ways
union1 = set1.union(set2)
union2 = set1 | set2

print(union1)
# {'apple', 'banana', 'cherry', 'date', 'elderberry'}

2. Real-World Efficient Patterns in 2026

# 1. Combining multiple sets
frontend = {"HTML", "CSS", "JavaScript", "React"}
backend = {"Python", "Django", "PostgreSQL"}
devops = {"Docker", "AWS", "Kubernetes"}

full_stack = frontend | backend | devops

# 2. Adding new items efficiently
skills = {"Python", "SQL"}
new_skills = {"FastAPI", "Docker", "AWS"}

skills = skills.union(new_skills)        # or skills |= new_skills

# 3. Merging user permissions
user_perms = {"read", "write"}
admin_perms = {"read", "write", "delete", "manage"}
all_perms = user_perms | admin_perms

3. Performance Comparison 2026

4. Best Practices with .union() in 2026

• Use the | operator for simple cases — it's more readable
• Use .union() when combining 3 or more sets
• Use |= for in-place union when appropriate
• Convert lists to sets first before doing repeated unions
• Chain operations when needed: set1 | set2 | set3

How union Works

a.union(b), or a | b, returns every item that appears in either set, with duplicates removed. The method can take several iterables at once, such as a.union(b, c, d), which is convenient when combining many sources.

update, or |=, adds items to an existing set in place. For dictionaries, | merges keys and values, but for sets it only combines items.

Union is a quick way to build a master list of unique ids from several files or months.

Worked Example: Combining Customer Lists

Customer ids from three months are combined into one unique set.

jan = [101, 102, 103, 101]
feb = [102, 104]
mar = [105, 101, 106]

all_customers = set(jan).union(feb, mar)
print(sorted(all_customers), len(all_customers))

seen = set()
for month in (jan, feb, mar):
    before = len(seen)
    seen |= set(month)
    print(f"new this month: {len(seen) - before}")

print(seen == all_customers)

The union contains six unique customers. Updating a running set month by month shows three new customers in January, one in February and two in March, and the final set matches the one-step union.

Practical Tips

For pandas columns, pd.concat([a, b]).unique() or pd.Index(a).union(b) gives the same result while keeping the data in pandas.

If you need to know where each item came from, a Counter or a dictionary of sets is more informative than a plain union, because the union discards the source.

Also remember that sets only store hashable values. Lists and dictionaries must be converted to tuples or frozensets before they can be combined with union.

Sort the final set with sorted() before printing it, since sets have no guaranteed order.

Common Mistakes

• Concatenating lists and forgetting to remove duplicates.
• Calling union in a loop and discarding the result.
• Expecting union to keep order.
• Using | with lists.

Quick Summary

• union combines unique items.
• The method accepts several iterables.
• |= updates in place.
• Great for building master id lists.

Conclusion — Set Method .union() in 2026

The .union() method and the | operator are the fastest and cleanest ways to combine sets in Python. In 2026, using these instead of manual loops or list operations is considered a basic best practice for writing efficient, readable, and maintainable code.

Next steps:

• Replace all manual set merging loops with | or .union()

Related Tutorials

• Getting Uniques with Sets in Python 2026 with Efficient Code
• Set Method .difference() in Python 2026 with Efficient Code