1

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

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

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

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

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

在这种情况下，尽管如此，该方法将不起作用，因为列表没有date属性......即使它有，如果它的属性与其父级不同，那么层次顺序就会被破坏。在 python 中是否有一种简单而优雅的方法来做到这一点？

4

4 回答 4

0

我认为您只需将密钥放入 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']]]]
于 2013-02-21T09:29:50.587 回答
0

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

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)
于 2013-02-21T19:56:05.853 回答
0

这是使用 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)
于 2013-02-21T12:31:50.510 回答
-1

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

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)
于 2013-02-21T03:49:13.087 回答