带多小数点的数字字符串排序异常求助：三段小数格式字符串降序问题

Hey there! The problem you're running into is a classic gotcha with version string sorting—regular lexicographical (string) comparison doesn't account for numeric segment values. For example, when comparing "5.8.1_64" to something like "5.10.0", the string comparison sees the "8" in the second segment as larger than "1" (from "10") because it's comparing individual characters by their ASCII values. That's why your 5.8.1_64 isn't landing at the end where it belongs.

The Solution: Custom Sort Keys Using Numeric Tuples #

The fix is to convert each version string into a tuple of integers that represent its core version segments. This way, the sorting logic compares actual numeric values instead of characters. Here's how to implement it:

Step 1: Write a Key Function

First, create a function that parses your version string into a sortable tuple. This handles the underscore suffix by extracting the core version first:

def get_version_sort_key(version_str):
    # Split off any suffix after the underscore (e.g., "_64")
    core_version = version_str.split('_')[0]
    # Split the core version into its decimal segments and convert to integers
    version_segments = tuple(map(int, core_version.split('.')))
    # If you need to sort by the suffix too (e.g., "_64" vs "_32"), add it to the tuple:
    # suffix = version_str.split('_')[1] if '_' in version_str else ''
    # return version_segments + (suffix,)
    return version_segments

Step 2: Sort Using the Custom Key

For a list of version strings, use this key with Python's sorted() function (reverse=True for descending order):

version_list = ["5.11.0", "5.8.1_64", "5.10.2", "5.9.1"]
sorted_versions = sorted(version_list, key=get_version_sort_key, reverse=True)
# Result: ["5.11.0", "5.10.2", "5.9.1", "5.8.1_64"]

Step 3: Adapt for Your Dictionary

Since you're working with a <string, object> dictionary, apply the same logic to sort the dictionary items or keys:

version_dict = {
    "5.10.2": some_object,
    "5.9.1": another_object,
    "5.8.1_64": third_object,
    "5.11.0": fourth_object
}
# Sort dictionary items by version (descending)
sorted_items = sorted(version_dict.items(), key=lambda x: get_version_sort_key(x[0]), reverse=True)
# Or get a sorted list of the version keys
sorted_keys = sorted(version_dict.keys(), key=get_version_sort_key, reverse=True)

Why This Works #

Tuples in Python compare element-by-element. So when comparing (5, 8, 1) (from 5.8.1_64) to (5, 10, 2) (from 5.10.2), the second element 8 is numerically smaller than 10, making the entire tuple smaller. This ensures the version with the lower segment value gets sorted to the end in descending order—exactly what you need.

If you ever have version strings with non-numeric segments (like "beta" or "rc"), you can extend the key function to handle those cases too, but for your current scenario of 3 decimal segments plus an underscore suffix, this approach will fix the sorting issue perfectly.

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