0

我有一个列表列表，每个列表包含四个元素，元素代表id, age, val1, val2。我以这样一种方式操作每个列表，即该列表的val1和val2 值始终取决于先前列表中看到的最新值。列表的先前列表是年龄差异不小于 的列表timeDelta。列表列表按年龄排序。

我的代码运行良好，但速度很慢。我觉得标记为* *的行生成了太多的列表列表，可以通过继续从开头删除列表来避免，我知道一个列表与下一个列表的年龄差异大于timeDelta.

myList = [
          [1,   20, '',     'x'],
          [1,   25, 's',    ''],
          [1,   26, '',     'e'],
          [1,   30, 'd',    's'],
          [1,   50, 'd',    'd'],
          [1,   52, 'f',    'g']
          ]


age_Idx =1
timeDelta = 10

for i in range(len(myList))[1:]:
    newList = myList[:i+1] #Subset of lists.  #********
    respList = newList.pop(-1) 
    currage = float(respList[age_Idx])
    retval = collapseListTogether(newList, age_Idx, currage, timeDelta)
    if(len(retval) == 0):
        continue
    retval[0:2] = respList[0:2]
    print(retval)

def collapseListTogether(li, age_Idx, currage, timeDelta):
    finalList = []
    for xl in reversed(li) :
        #print(xl)
        oldage = float(xl[age_Idx])
        if ((currage-timeDelta) <= oldage < currage):
            finalList.append(xl)
        else:
            break
    return([reduce(lambda a, b: b or a, tup) for tup in zip(*finalList[::-1])])

例子

[1, 20, '',     'x'] ==> Not dependent on anything. Skip this list
[1, 25, 's',    '']    == > [1, 25, '', 'x'] 
[1, 26, '',     'e']   ==>  [1, 26, 's', 'x']
[1, 30, 'd',    's']   ==>  [1, 30, 's', 'e']
[1, 50, 'd',    'd']   ==>  Age difference (50-30 = 20) which is more than 10 
[1, 52, 'f',    'g']   ==>  [1, 52, 'd', 'd']
4

2 回答 2

0

我只是重写你的数据结构和你的代码：

from collections import namedtuple
Record = namedtuple('Record', ['id', 'age', 'val1', 'val2'])
myList = [
      Record._make([1,   20, '',     'x']),
      Record._make([1,   25, 's',    '']),
      Record._make([1,   26, '',     'e']),
      Record._make([1,   30, 'd',    's']),
      Record._make([1,   50, 'd',    'd']),
      Record._make([1,   52, 'f',    'g'])
]

timeDelta = 10

for i in range(1, len(myList)):
    subList = list(myList[:i+1])
    rec = supList.pop(-1) 
    age = float(rec.age)
    retval = collapseListTogether(subList, age, timeDelta)
    if len(retval) == 0:
        continue
    retval.id, retval.age = rec.id, rec.age
    print(retval)

def collapseListTogether(lst, age, tdelta):
    finalLst = []
    [finalLst.append(ele) if age - float(ele.age) <= tdelta and age > float(ele.age)
     else None for ele in lst]
    return([reduce(lambda a, b: b or a, tup) for tup in zip(*finalLst[::-1])])

你的代码对我来说是不可读的。我没有改变逻辑，只是修改了性能的地方。

一种出路是用元组替换你的 4 元素列表，用命名元组更好，它是 Python 中著名的高性能容器。此外，在解释语言中应避免使用 for 循环。在 python 中，如果可能的话，人们会使用理解而不是 for 循环来提高性能。您的列表并不太大，因此在高效的线路口译中获得的时间应该比在破译中获得的时间更多。

对我来说，你的代码不应该工作，但我不确定。

于 2013-08-14T20:42:36.830 回答
0

假设您的示例是正确的，我认为您没有理由不能一次性完成此操作，因为它们是按年龄排序的。如果您检查的最后一个子列表差异太大，您不知道之前的任何内容都不会计算在内，因此您应该保持当前子列表不变。

previous_age = None
previous_val1 = ''
previous_val2 = ''

for sublist in myList:
    age = sublist[1]
    latest_val1 = sublist[2]
    latest_val2 = sublist[3]
    if previous_age is not None and ((age - previous_age) <= timeDelta):
        # there is at least one previous list            
        sublist[2] = previous_val1
        sublist[3] = previous_val2
    previous_age = age
    previous_val1 = latest_val1 or previous_val1
    previous_val2 = latest_val2 or previous_val2

测试时，该代码会为您的初始 myList 生成此修改后的值：

[[1, 20, '', 'x'],
 [1, 25, '', 'x'],
 [1, 26, 's', 'x'],
 [1, 30, 's', 'e'],
 [1, 50, 'd', 'd'],
 [1, 52, 'd', 'd']]

构建一个新列表而不是在原地编辑一个列表，或者完全省略跳过的行而不是保持不变，这是一个简单的修改。

reduce 和 list 推导是强大的工具，但它们并不适合所有问题。

于 2013-08-14T20:50:05.760 回答