Python中用字典模拟集合时添加元素的更优实现方式咨询

Great question! Let's unpack this step by step.

First, a quick clarification: dictionaries in Python don't have .add() or .insert() methods—those belong to built-in types like set or list. So we have to work with the tools dictionaries do provide, which revolve around their core feature: unique keys.

Why result[x] = 0 works (and its limitations) #

The example uses result[x] = 0 because it leverages dictionary key uniqueness: if x is already in the dictionary, assigning 0 just overwrites the existing value (which we don't care about anyway—we only need the key to exist to represent membership in the "set"). This works perfectly fine, but there are cleaner, more idiomatic ways to do the same thing.

Better alternatives to add elements to the dictionary-based "set" #

Here are a few more efficient and readable approaches:

1. Use dict.setdefault()
   This method checks if a key exists; if not, it adds the key with a default value (if you don't specify one, it uses None). It avoids unnecessary overwrites if the key is already present:

   def t_or(l1, l2):
       result = {}
       for x in l1:
           result.setdefault(x, None)  # Value can be anything—we only care about the key
       for x in l2:
           result.setdefault(x, None)
       return list(result.keys())  # Return the "set" as a list of elements
   

2. Use dict.fromkeys() for bulk creation
   This is a concise way to create a dictionary from an iterable, where all keys are the iterable's elements and values default to None. You can combine it with dict.update() to merge two "sets" quickly:

   def t_or(l1, l2):
       union_dict = dict.fromkeys(l1)
       union_dict.update(dict.fromkeys(l2))  # Bulk-add all elements from l2
       return list(union_dict.keys())
   

3. One-liner for simplicity
   If you prefer brevity, you can merge the lists first and use dict.fromkeys() to automatically deduplicate:

   def t_or(l1, l2):
       return list(dict.fromkeys(l1 + l2).keys())
   

   Note: This creates a new list (l1 + l2) which might use extra memory for very large datasets, but it's great for most common use cases.

Bonus: Full implementation of all four set operations #

Since your original task is to implement |, -, ^, & using dictionaries, here's a complete, idiomatic implementation using the above techniques:

def set_union(l1, l2):
    """Simulate set union (|): elements in either l1 or l2"""
    union_dict = dict.fromkeys(l1)
    union_dict.update(dict.fromkeys(l2))
    return list(union_dict.keys())

def set_intersection(l1, l2):
    """Simulate set intersection (&): elements in both l1 and l2"""
    # Convert one list to a dict for O(1) lookups
    l1_dict = dict.fromkeys(l1)
    # Filter elements in l2 that exist in l1_dict
    intersection = [x for x in l2 if x in l1_dict]
    # Ensure no duplicates (in case input lists have repeats)
    return list(dict.fromkeys(intersection).keys())

def set_difference(l1, l2):
    """Simulate set difference (-): elements in l1 but not in l2"""
    l2_dict = dict.fromkeys(l2)
    difference = [x for x in l1 if x not in l2_dict]
    return list(dict.fromkeys(difference).keys())

def set_symmetric_difference(l1, l2):
    """Simulate symmetric difference (^): elements in exactly one of l1 or l2"""
    union = set_union(l1, l2)
    intersection = set_intersection(l1, l2)
    intersection_dict = dict.fromkeys(intersection)
    return [x for x in union if x not in intersection_dict]

# Test it out!
l1 = [1,2,3,4,5]
l2 = [4,5,6,7,8]
print("Union:", set_union(l1, l2))        # [1, 2, 3, 4, 5, 6, 7, 8]
print("Intersection:", set_intersection(l1, l2))  # [4, 5]
print("Difference (l1 - l2):", set_difference(l1, l2))  # [1, 2, 3]
print("Symmetric Difference:", set_symmetric_difference(l1, l2))  # [1, 2, 3, 6, 7, 8]

Key takeaway #

The core idea of using a dictionary as a set is that we only care about the presence of keys—their values are irrelevant. So any method that adds keys to the dictionary (without worrying about the value) works, but dict.fromkeys() and dict.update() are more concise and Pythonic than manual loops with assignment.

内容的提问来源于stack exchange，提问作者user17033146