Parallel Value Comparison Across Python Dictionaries with Divergent Keys

Beginning with Python 3.7, the native dictionary data structure enforces insertion-order preservation. This guarantee allows developers to perform sequential operations on mappings even when the key identifiers do not overlap, provided both structures contain an identical number of entries.

A common requirement involves evaluating two such dictionaries in parallel order. The goal is to traverse both mappings simultaneously, detect positionss where the stored values differ, and construct a new container that retains the primary dictionary's keys while adopting the secondary dictionary's values at those specific indices.

Processing Workflow

The execution follows a deterministic sequence:

• Initialize an empty result container to collect discrepancies.
• Create a value-only iterator from the secondary dictionary to enable sequential access independent of key names.
• Iterate through the primary dictionary using its guaranteed insertion order.
• Retrieve the current value from the primary dictionary and advance the secondary iterator to obtain the corresponding positional value.
• Compare the two values directly.
• If a mismatch is detected, record the primary dictionary's key paired with the secondary dictionary's value into the result container.
• Continue until all entries are exhausted, then return the populated mapping.

Code Implementation

def extract_value_mismatches(primary_dict, secondary_dict):
    """
    Compares two equally-sized dictionaries by insertion order.
    Returns a new dictionary containing keys from primary_dict 
    and values from secondary_dict where they do not match.
    """
    result_map = {}
    
    # Validate structural compatibility
    if len(primary_dict) != len(secondary_dict):
        raise ValueError("Both dictionaries must contain an equal number of items.")
        
    # Prepare sequential access to secondary values
    secondary_value_stream = iter(secondary_dict.values())
    
    # Traverse primary dictionary in guaranteed insertion order
    for current_key in primary_dict:
        primary_value = primary_dict[current_key]
        secondary_value = next(secondary_value_stream)
        
        # Capture discrepancies
        if primary_value != secondary_value:
            result_map[current_key] = secondary_value
            
    return result_map

Execution Example

The following demonstrates how to apply the function to two sample datasets with complete different key sets:

source_data = {
    "alpha":  "first_item",
    "beta":   "second_item",
    "gamma":  "third_item"
}

target_data = {
    "x_axis": "first_item",
    "y_axis": "alternate_second",
    "z_axis": "void"
}

discrepancies = extract_value_mismatches(source_data, target_data)
print(discrepancies)

Executing this script produces the following output, isolating only the positional mismatches:

{'beta': 'alternate_second', 'gamma': 'void'}