Python 如何使用特定规则对列表进行排序

嗨，我有复杂的数据对象，我想通过s排序。简化版本如下：

class Data(object):
    def __init__(self, s):
        self.s = s

每个数据对象都将放在特定的类别中，以便以后使用。简化版再次在下面

class DataCategory(object):
    def __init__(self, id1, id2, linked_data=None):
        self.id1 = id1
        self.id2 = id2
        self.ld = linked_data

我想按数据的s编号对下面的数据进行排序，但没有更多的规则。若第一次数据采集使用了一个数据对象，若s编号相同或更低，我希望使用第二次采集的一个数据对象。这是我得到的和我想要实现的

# order I get
# [['p02g01r05', 5], ['p02g01r01', 4], ['p01g01r05', 4], ['p01g01r01', 3], ['p01g01r02', 2], ['p01g01r03', 2], ['p01g01r06', 2], ['p02g01r02', 2], ['p02g01r03', 2], ['p02g01r04', 2], ['p01g01r04', 1], ['p02g01r06', 1]]
# order I want
# [['p02g01r05', 5], ['p01g01r05', 4], ['p02g01r01', 4], ['p01g01r01', 3], ['p02g01r02', 2], ['p01g01r02', 2], ['p02g01r03', 2], ['p01g01r03', 2], ['p02g01r04', 2], ['p01g01r06', 2], ['p02g01r06', 1]], ['p01g01r04', 1]

到目前为止，这是我创造的，但我认为我走错了方向。我认为要替换的索引列表是正确的

# Some data objects
p01g01r01 = Data(3)
p01g01r02 = Data(2)
p01g01r03 = Data(2)
p01g01r04 = Data(1)
p01g01r05 = Data(4)
p01g01r06 = Data(2)

p02g01r01 = Data(4)
p02g01r02 = Data(2)
p02g01r03 = Data(2)
p02g01r04 = Data(2)
p02g01r05 = Data(5)
p02g01r06 = Data(1)

p01g01 = DataCategory("01", "01", [])
p02g01 = DataCategory("02", "01", [])


# link data to data category
def ldtdc(dc):
    lst = []
    data = "p" + dc.id1 + "g" + dc.id2 + "r"
    for i in range(1, 7):
        if i < 10:
            lst.append(data + "0" + str(i))
        else:
            lst.append(data + str(i))
    return lst

p01g01.ld = ldtdc(p01g01)
p02g01.ld = ldtdc(p02g01)


# /@= This starts to get way too complicated fast ############################
def lstu(ag, dg):
    lst = []
    # data list of first collection
    dlofc = []
    # data list of second collection
    dlosc = []

    # for every data unit that exists in data collection
    for unit in ag.ld:
        # lst.append([unit, globals()[unit].s+10])
        lst.append([unit, globals()[unit].s])
        dlofc.append([unit, globals()[unit].s])

    for unit in dg.ld:
        lst.append([unit, globals()[unit].s])
        dlosc.append([unit, globals()[unit].s])

    # lambda function is used here to sort list by data value ([1] is index of the item)
    lst = sorted(lst, key=lambda x: x[1], reverse=True)
    # current index
    ci = 0

    previous_data = ["last data unit will be stored here", 0]
    # sorted list
    slst = []

    for unit in lst:
        try:
            next_data = lst[ci+1]
        except IndexError:
            next_data = ["endoflist", 0]
        if previous_data[0] == "last data unit will be stored here":
            pass
        elif previous_data[0][:6] == unit[0][:6]:
            if unit[0][:6] not in dlofc[0][0]:
                slst.append([unit[0], unit[1], ci])
            elif unit[0][:6] not in dlosc[0][0]:
                slst.append([unit[0], unit[1], ci])
            else:
                print "Error"

        previous_data = unit
        ci += 1

    print "slist below"
    print slst

    return lst
# \@= END #####################################################################


print p01g01.ld
print p02g01.ld


data_list = lstu(p01g01, p02g01)
print data_list

#一些数据对象
p01g01r01=数据（3）
p01g01r02=数据（2）
p01g01r03=数据（2）
p01g01r04=数据（1）
p01g01r05=数据（4）
p01g01r06=数据（2）
p02g01r01=数据（4）
p02g01r02=数据（2）
p02g01r03=数据（2）
p02g01r04=数据（2）
p02g01r05=数据（5）
p02g01r06=数据（1）
p01g01=数据类别（“01”，“01”，“[]））
p02g01=数据类别（“02”，“01”，“[]））
#将数据链接到数据类别
def ldtdc（dc）：
lst=[]
data=“p”+dc.id1+“g”+dc.id2+“r”
对于范围（1,7）内的i：
如果i<10：
一级追加（数据+0+str（一））
其他：
一级追加（数据+str（i））
返回lst
p01g01.ld=ldtdc（p01g01）
p02g01.ld=ldtdc（p02g01）
#/@=这开始变得太复杂了############################
def lstu（ag、dg）：
lst=[]
#第一次收集的数据列表
dlofc=[]
#第二次收集的数据列表
dlosc=[]
#对于数据采集中存在的每个数据单元
对于ag.ld中的单位：
#lst.append（[unit，globals（）[unit].s+10]）
追加（[unit，globals（）[unit].s]）
dlofc.append（[unit，globals（）[unit].s]）
对于dg.ld中的装置：
追加（[unit，globals（）[unit].s]）
dlosc.append（[unit，globals（）[unit].s]）
#lambda函数用于按数据值对列表进行排序（[1]是项的索引）
lst=排序（lst，key=lambda x:x[1]，reverse=True）
#当前索引
ci=0
previous_data=[“最后一个数据单元将存储在这里”，0]
#排序表
slst=[]
对于lst中的单位：
尝试：
下一步数据=lst[ci+1]
除索引器外：
next_data=[“endoflist”，0]
如果上一个_数据[0]=“最后一个数据单元将存储在此处”：
通过
elif上一个_数据[0][：6]==单位[0][：6]：
如果单元[0][：6]不在dlofc[0][0]中：
slst.append（[单元[0]，单元[1]，ci]）
elif单元[0][：6]不在dlosc[0][0]中：
slst.append（[单元[0]，单元[1]，ci]）
其他：
打印“错误”
以前的数据=单位
ci+=1
打印“下面的列表”
打印单反
返回lst
#\@=结束#####################################################################
打印p01g01.ld
打印p02g01.ld
数据列表=lstu（p01g01、p02g01）
打印数据列表

---

什么是对这些数据进行快速正确排序的方法？

您是否尝试过先按字符串排序，然后再按项目中的数字排序

>>> items = [['p02g01r05', 5], ['p02g01r01', 4], ['p01g01r05', 4], ['p01g01r01', 3], ['p01g01r02', 2], ['p01g01r03', 2], ['p01g01r06', 2], ['p02g01r02', 2], ['p02g01r03', 2], ['p02g01r04', 2], ['p01g01r04', 1], ['p02g01r06', 1]]
>>> partially_sorted = sorted(items, key=lambda item: item[0], reverse=True)
>>> sorted(partially_sorted, key=lambda item: item[1], reverse=True)
[['p02g01r05', 5], ['p02g01r01', 4], ['p01g01r05', 4], ['p01g01r01', 3], ['p02g01r04', 2], ['p02g01r03', 2], ['p02g01r02', 2], ['p01g01r06', 2], ['p01g01r03', 2], ['p01g01r02', 2], ['p02g01r06', 1], ['p01g01r04', 1]]

---

找到了解决办法。新的lstu功能：

# replaced lambda with normal function
def get_key(item):
    return item[1]


def lstu(ag, dg):
    # ag list
    agslst = []
    # dg list
    dgslst = []

    # for every unit in first data collection
    for unit in ag.u:
        agslst.append([unit, globals()[unit].s])
    # sorted first data collection list
    agslst = sorted(agslst, key=get_key, reverse=True)
    print agslst

    for unit in dg.u:
        dgslst.append([unit, globals()[unit].s])
    # 2nd collection sorted list
    dgslst = sorted(dgslst, key=get_key, reverse=True)
    print dgslst

    lst = []
    # last item
    li = ["Empty", 0]

    for item in range(0, len(agslst)+len(dgslst)+1):
        if agslst and dgslst:
            if agslst[0][1] == dgslst[0][1]:
                if li[0][:6] == agslst[0][0][:6]:
                    li = dgslst.pop(0)
                    lst.append(li)
                else:
                    li = agslst.pop(0)
                    lst.append(li)

            elif agslst[0][1] > dgslst[0][1]:
                li = agslst.pop(0)
                lst.append(li)
            else:
                li = dgslst.pop(0)
                lst.append(li)

    return lst

通过这种方式，我满足了前面提到的新（和最终）列表的要求

输出：

[['p02g01r05', 5], ['p01g01r05', 4], ['p02g01r01', 4], ['p01g01r01', 3], ['p02g01r02', 2], ['p01g01r02', 2], ['p02g01r03', 2], ['p01g01r03', 2], ['p02g01r04', 2], ['p01g01r06', 2], ['p02g01r06', 1]], ['p01g01r04', 1]]

---

我愿意接受任何优化建议。

您是否考虑过

sorted

函数或

list.sort

方法？在上面的示例中，您可以看到我已经使用了sorted，但它不足以满足新列表的所有要求您知道/意识到您可以控制

sorted

和

list.sort

排序时比较元素？一旦你能控制它，我不明白你为什么不能使用

sorted

或

list.sort

。它不会工作。如果有相同的“s”，则p01g01中应有一项，p02g01中应有一项。在上面的例子中，我们将从同一个集合中获得许多具有相同“s”的项。这基本上是合并两个排序列表吗？一个排序列表名为p01g01，另一个是p02g01？不，python排序是稳定的