Why does a set remove duplicate values but not keep my original order?

Not necessarily. The important point is that a set does not promise to retain the order of the list you converted. Python describes sets as unordered collections of unique elements and warns that their iteration or printed output can appear in an unexpected order [S1]. A set is a good fit when you care about whether a value is present or want unique membership; it is not the right container for remembering the original positions.

For example, if your input is ['pear', 'apple', 'pear', 'plum'], converting it to a set can remove the repeated 'pear', but you should not rely on the resulting display order matching the input. The original list represents the sequence you received; the set represents unique membership.

Keep a list for the output and use a set only to check whether each value has appeared before. Walk through the input from left to right: add a value to the result list the first time you see it, and skip later occurrences. That way, the list records the first-seen order while the set handles the membership check.

Copyable example:

values = ['pear', 'apple', 'pear', 'plum', 'apple']
seen = set()
unique_in_order = []

for value in values:
    if value not in seen:
        unique_in_order.append(value)
        seen.add(value)

print(unique_in_order)
# ['pear', 'apple', 'plum']

Here, the list is the ordered result. The set is not used as the output; it is just a record of values already encountered. This example assumes the values are suitable for set membership, as ordinary strings are.

You can use sorted(set(values)) when you want unique values in sorted order. But sorting creates a different order; it does not restore the order in which values first appeared in your input [S1]. For the example above, sorting would put the unique strings in alphabetical order rather than leaving 'pear' first.

Choose based on what “predictable” means for your task:

1. Keep first-seen order: build a result list while checking a separate set, as in the example.
2. Use sorted order: sort the unique values if alphabetical or other sorted output is what you want.
3. Use a set alone: do that when uniqueness or membership matters and sequence order does not.

Look at what the next part of your program expects. If it displays values in the same sequence they arrived, compares positions, or processes the first item before later items, preserve an ordered list. If it only asks whether a value exists or needs a collection of unique members without relying on their sequence, a set may fit. If the required output is sorted, sort the unique values explicitly.

A practical check is to write down the intended output for an input containing a repeat that appears after other values. For ['pear', 'apple', 'pear', 'plum'], first-seen deduplication should give ['pear', 'apple', 'plum']. If that is your desired result, retain the list-based approach and use the set only for membership checks.