对嵌套列表进行排序

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)