Question

我有一个描述层次结构的列表，如下：

[obj1, obj2, [child1, child2, [gchild1, gchild2]] onemoreobject]

其中，child1（和其他人）是obj2的孩子，而gchild1和2是孩子2的孩子。

例如，每个对象都有date等属性，我想根据这些属性对它们进行排序。在常规列表中，我会这样：

sorted(obj_list, key=attrgetter('date'))

在这种情况下，尽管如此，该方法不起作用，因为列表没有date属性...即使它确实如此，如果它的属性与其父类不同，那么分层排序将被打破。在python中有一种简单而优雅的方法吗？

Answer 1

我认为你只需要将你的密钥放在sort（key = None）函数中，这样就行了。我用字符串测试它似乎工作。我不确定onemoreobject的结构。这是用obj1和obj2开头的。我认为onemoreobject可能代表一个新的层次结构，所以我将每个层次结构包含在一个列表中，以便将对象保持在一起。

def embededsort(alist):
  islist = False
  temp = []
  for index, obj in enumerate(alist):
    if isinstance(obj,list):
      islist = True
      embededsort(obj)
      temp.append((index,obj))
  if islist:
    for lists in reversed(temp):
      del alist[lists[0]]
    alist.sort(key=None)
    for lists in temp:
      alist.append(lists[1])
  else:
    alist.sort(key=None)
  return alist

>>>l=[['obj2', 'obj1', ['child2', 'child1', ['gchild2', 'gchild1']]], ['obj22', 'obj21', ['child22', 'child21', ['gchild22', 'gchild21']]]]  
>>>print(embededsort(l))
[['obj1', 'obj2', ['child1', 'child2', ['gchild1', 'gchild2']]], ['obj21', 'obj22', ['child21', 'child22', ['gchild21', 'gchild22']]]]

Answer 2

这是使用Python提供的多态性的QuickSort算法的实现。它应该适用于整数，浮点数，列表，嵌套列表，元组甚至字典

def qsort(list):
    if not list: return []
    first   = list[0]
    lesser  = filter( lambda x: x <  first, list[1:] )
    greater = filter( lambda x: x >= first, list[1:] )
    return qsort(lesser) + [first] + qsort(greater)

Answer 3

感谢您的回答，因为他们给了我很多想法，以及要学习的新东西。似乎工作的最终代码看起来像这样。不像我想象的那样充满优雅和优雅，但有效：

def sort_by_date(element_list):
    last_item = None
    sorted_list = []
    for item in element_list:
        #if item is a list recurse and store it right below last item (parent)
        if type(item) == list:
            if last_comparisson:
                if last_comparisson == 'greater':
                    sorted_list.append(sort_by_date(item))
                else:
                    sorted_list.insert(1, sort_by_date(item))
        #if not a list check if it is greater or smaller then last comparisson
        else:
            if last_item == None or item.date > last_item:
                last_comparisson = 'greater'
                sorted_list.append(item)
            else:
                last_comparisson = 'smaller'
                sorted_list.insert(0, item)
            last_item = item.date
    return(sorted_list)

Answer 4

如果要对节点的所有子节点进行排序而不考虑那些不是兄弟节点的节点，请选择树结构：

class Tree:
    def __init__ (self, payload):
        self.payload = payload
        self.__children = []

    def __iadd__ (self, child):
        self.__children.append (child)
        return self

    def sort (self, attr):
        self.__children = sorted (self.__children, key = lambda x: getattr (x.payload, attr) )
        for child in self.__children: child.sort (attr)

    def __repr__ (self):
        return '{}: {}'.format (self.payload, self.__children)

通过嵌套列表排序

4 个答案: