Python - 带有字母数字的人类数字排序，但在 pyQt 和 __lt__ 运算符中

Question

我有数据行并希望将它们呈现如下：

1
1a
1a2
2
3
9
9.9
10
10a
11
100
100ab
ab
aB
AB

由于我使用 pyQt 并且代码包含在 TreeWidgetItem 中，所以我试图解决的代码是：

def __lt__(self, otherItem):
    column = self.treeWidget().sortColumn()

    #return self.text(column).toLower() < otherItem.text(column).toLower()

    orig = str(self.text(column).toLower()).rjust(20, "0")
    other = str(otherItem.text(column).toLower()).rjust(20, "0")
    return orig < other

Answer 1

这可能对你有帮助。编辑正则表达式以匹配您感兴趣的数字模式。我的会将任何包含 . 的数字字段视为浮点数。使用 swapcase() 反转大小写，以便 'A' 排序在 'a' 之后。

更新：精炼：

import re

def _human_key(key):
    parts = re.split('(\d*\.\d+|\d+)', key)
    return tuple((e.swapcase() if i % 2 == 0 else float(e))
            for i, e in enumerate(parts))

nums = ['9', 'aB', '1a2', '11', 'ab', '10', '2', '100ab', 'AB', '10a',
    '1', '1a', '100', '9.9', '3']
nums.sort(key=_human_key)

print '\n'.join(nums)

输出：

1
1a
1a2
2
3
9
9.9
10
10a
11
100
100ab
ab
aB
AB

更新：（对评论的回应）如果您有一个类Foo并且想要实现__lt__ 使用 _ human_key 排序方案，只需返回 _ human_key(k1) 的结果_ human_key(k2);

class Foo(object):

    def __init__(self, key):
        self.key = key

    def __lt__(self, obj):
        return _human_key(self.key) < _human_key(obj.key)

>>> Foo('ab') < Foo('AB')
True
>>> Foo('AB') < Foo('AB')
False

因此，对于您的情况，您需要执行以下操作：

def __lt__(self, other):
    column = self.treeWidget().sortColumn()
    k1 = self.text(column)
    k2 = other.text(column)
    return _human_key(k1) < _human_key(k2)

其他比较运算符（__eq__、__gt__ 等）将以相同的方式实现。

Answer 2

使用 samplebias 的 swapcase 想法，以及 Ned Batchelder 的 人类排序代码，你可以这样做：

import re
def human_keys(astr):
    '''
    alist.sort(key=human_keys) sorts in human order
    '''
    keys=[]
    for elt in re.split('(\d+)', astr):
        elt=elt.swapcase()
        try: elt=int(elt)
        except ValueError: pass
        keys.append(elt)
    return keys

x='''
    1
    1a
    1a2
    2
    3
    9
    9.9
    9.10
    9a2
    10
    10a
    11
    100
    100ab
    ab
    aB
    AB
    '''.split()

print(x)
assert x == sorted(x,key=human_keys)

---

你可以在__lt__中应用human_keys，如下所示：

def __lt__(self, otherItem):
    column = self.treeWidget().sortColumn()
    orig = str(self.text(column).toLower()).rjust(20, "0")
    other = str(otherItem.text(column).toLower()).rjust(20, "0")
    return human_keys(orig) < human_keys(other)

Answer 3

我不明白你的排序算法，所以我无法告诉你如何实现它。但有一个通用的技巧，那就是使用Python内置的sort函数中的key参数。换句话说，您想要对数据进行一些转换，Python 会按正确的顺序进行排序，然后将该转换编写为 Python 函数 foo 并调用 sort(data,键=foo）。

---

示例：如果您有一个字符串列表 "-"，请说 ["1-1","1-2 ","3-1"] 并且您想按第二个数字排序，然后按第一个数字排序，请注意，如果数据采用 [(1,1), (2,1), (1,3)] 即反转元组列表。因此，您可以编写一个函数

def key(s):
    l, r = s.split("-")
    return int(r), int(l)

，然后使用 sort(l, key=key) 对列表进行排序。

Answer 4

这是一个函数，给定一个混合有字母和数字部分的字符串，返回一个以“自然”方式排序的元组。

def naturalkey(key, convert=int):
    if not key:
        return ()
    keys = []
    start = 0
    extra = ""
    in_num = key[0].isdigit()
    for i, char in enumerate(key):
        if start < i:
            if in_num:
                try:
                    last_num = convert(key[start:i])
                except:
                    in_num = False
                    if i > 2 and key[i-2] == ".":
                        extra = "."
                    keys.append(last_num)
                    start = i-1
            if not in_num:  # this is NOT equivalent to `else`!
                if char.isdigit():
                    keys.append(extra + key[start:i])
                    in_num = True
                    start = i
                    extra = ""
                    last_num = convert(char)
    keys.append(last_num if in_num else (extra + key[start:]))
    return tuple(keys)

它使用的基本方法是，当它看到一个数字时，它会收集额外的字符并不断尝试将结果转换为数字，直到它不能再转换为止（即它收到异常）。默认情况下，它会尝试将连续字符转换为整数，但您可以传入 convert=float 以使其接受小数点。 （不幸的是，它不接受科学记数法，因为要得到像“1e3”这样的东西，它首先会尝试解析无效的“1e”。这与+或-号一起，可能是特殊情况，但它并不看起来这对于您的用例来说不是必需的。）

该函数返回一个包含字符串和数字的元组，按照它们在字符串中找到的顺序排列，并将数字解析为指定的数字类型。例如：

naturalkey("foobar2000.exe")
>>> ("foobar", 2000, ".exe")

该元组可以用作对字符串列表进行排序的键：

my_list.sort(key=lambda i: naturalkey(i, float))

或者您可以使用它来实现比较功能：

def __lt__(self, other):
    return naturalkey(self.value, float) < naturalkey(other.value, float)

在对象的 __init__() 中生成自然键会更好（更快） 方法，将其存储在实例中，然后编写比较函数以使用存储的值。如果派生键的值是可变的，您可以编写一个属性，在更新基础值时更新键。