Question

继my previous question之后，我现在正在读取两个文件A和B，并将2009年的日期放入AB2对象（subAB）的列表中，然后排在第一个非2009行。

class AB2(object):
    def __init__(self, datetime, a=False, b=False):
        self.datetime = datetime
        self.a = a
        self.b = b
        self.subAB = []

例如：

file A: 20111225, 20111226, 20090101
file B: 20111225, 20111226, 20090101, 20090102, 20111227, 20090105

应该导致:(方括号显示subAB列表）

AB2(20111225, a = true, b = true, [])
AB2(20111226, a = true, b = true, 
    [AB2(20090101, a = true, b = true, []),
     AB2(20090102, a = false, b = true, [])], 
AB2(20111227, a = false, b = true, 
    [AB2(20090105, a = false, b = true)])

不幸的是，这使以前的解决方案变得复杂：

list_of_objects = [(i, i in A, i in B) for i in set(A) | set(B)]

由于：

订单很重要（2009年项目进入文件中的第一个2011项目）
文件
现在也对subAB对象列表感兴趣

由于这些原因，我们不能使用当前存在的set（因为它会删除重复项并丢失顺序）。我已经探索过使用OrderedSet recipe，但我想不出在这里应用它的方法。

我目前的代码：

listA = open_and_parse(file A) # list of parsed dates
listAObjects = [AB2(dt, True, None) for dt in listA] # list of AB2 Objects from list A
nested_listAObjects = nest(listAObjects) # puts 2009 objects into 2011 ones
<same for file B>
return combine(nested_listAObjects, nested_listBObjects)

Nest方法:(将2009年的项目放入上一个2011年的项目。如果它们位于文件的开头，则忽略2009项目）

def nest(list):
    previous = None
    for item in list:       
        if item.datetime.year <= 2009:
            if previous is not None:
                previous.subAB.append(item)
            else:
                previous = item

    return [item for item in list if item.datetime.year > 2009]

但我对combine功能有点困惑：

def combine(nestedA, nestedB):
    combined = nestedA + nestedB
    combined.sort(key=lambda x: x.datetime)

    <magic>

    return combined

此时，如果没有魔法，combined将如下所示：

AB2(20111225, a = true, b = None, []) # \ 
AB2(20111225, a = None, b = true, []) # / these two should merge to AB2(20111225, a = true, b = true, [])
AB2(20111226, a = true, b = None, 
    [AB2(20090101, a = true, b = None, []),
     AB2(20090102, a = true, b = None, [])], 
AB2(20111226, a = None, b = true, 
    [AB2(20090101, a = None, b = true, [])], 
# The above two lines should combine, and so should their subAB lists (but only recurse to that level, not infinitely)
AB2(20111227, a = None, b = true, 
    [AB2(20090105, a = None, b = true)])

我希望我能发布一个新问题 - 这将是我之前的一个完全不同的解决方案。也很遗憾长篇文章，我认为最好解释我正在做的所有事情，这样你就可以完全理解这个问题，也许可以为整个问题提供另一种解决方案，而不仅仅是{{1} } 方法。谢谢！

修改：澄清：

基本上，我正在检查来自两台连接的计算机的日志，并比较它们是在特定时间关闭还是仅关闭一台。计算机在2009年时启动（但不总是1月1日 - 有时是1月4日等）如果他们重置之前他们可以检索真正的2012年时间。因此，我试图将随后的2009年关闭与之前的关闭联系起来，以便我知道它何时快速重置。

2011/2012日期应进行排序，但2009年的日期不是。一台计算机的日志文件（在我的示例中为combine）可能如下所示：

fileA

实际上，它们实际上是日期时间（例如2011/12/15 2011/12/17 2011/12/19 # Something goes wrong, and causes the computer to reset 5 times rapidly 2009/01/01 2009/01/01 2009/01/04 2009/01/01 2011/12/20 # And everything is better again 2011/12/25），因此我可以简单地比较两个日期时间是否在某个2009/01/01 01:57:01内。

我要么采用更清洁的整体解决方案/方法，要么是针对组合这两个timedelta对象列表的问题的特定解决方案。

组合这两者的最简单方法是遍历已排序的组合列表（已将2009对象放入其父项），比较下一项是否与当前项相同，并从这些创建新列表项目。

Answer 1

这对比较有点棘手，而且可能采用更简洁的方法，但这似乎有效并应该相对有效。

我假设日期的顺序很重要。从两个输入流中比较增加的日期并组合，当前一个日期发生时，它们被收集，组合并附加到之前的较大日期。

为简洁起见，我刚刚在此示例中创建了元组而不是AB2类的实例。

from cStringIO import StringIO
fileA = StringIO("""20111225, 20111226, 20090101""")
fileB = StringIO("""20111225, 20111226, 20090101, 20090102, 20111227, 20090105""")

def fileReader(infile):
  for line in infile:
    for part in line.split(','):
      yield part.strip()

def next_or_none(iterable):
  for value in iterable:
    yield value
  yield None

def combine(a,b):
  current_val = None
  hasA = hasB = False
  next_a, next_b = next_or_none(a).next, next_or_none(b).next
  current_a, current_b = next_a(), next_b()
  while True:
    if current_val is None:
      if current_a == current_b:
        current_val = current_a
        hasA = hasB = True
        current_a, current_b = next_a(), next_b()
      elif current_a is not None and (current_b is None or current_a < current_b):
        current_val = current_a
        hasA = True
        current_a = next_a()
      elif current_b is not None and (current_a is None or current_b < current_a):
        current_val = current_b
        hasB = True
        current_b = next_b()
      else:
        break
    else: # There's a current_val
      sub_a = []
      while current_a is not None and current_a < current_val:
        sub_a.append(current_a)
        current_a = next_a()
      sub_b = []
      while current_b is not None and current_b < current_val:
        sub_b.append(current_b)
        current_b = next_b()
      if sub_a or sub_b:
        sub_ab = list(combine(sub_a,sub_b))
      else:
        sub_ab = []
      yield (current_val,hasA,hasB,sub_ab)
      current_val = None
      hasA = hasB = False

for row in combine(fileReader(fileA),fileReader(fileB)):
  print row

收率：

('20111225', True, True, [])
('20111226', True, True, [('20090101', True, True, []), ('20090102', False, True, [])])
('20111227', False, True, [('20090105', False, True, [])])

Python通过比较日期时间来递归地组合两个对象列表

1 个答案: