Question

我正在寻找有关如何使用两个嵌套循环以最快的方式解析单个列表的建议，避免进行len(list)^2比较，并避免在组中重复文件。

更准确地说：我有一个'文件'对象列表，每个对象都有一个时间戳。我想按时间戳和时间偏移对文件进行分组。防爆。从文件X开始，我想创建一个包含所有timestamp < (timestamp(x) + offset)文件的组。

为此，我做了：

for file_a in list:
   temp_group = group()
   temp_group.add(file_a)
   list.remove(file_a)
   for file_b in list:
      if (file_b.timestamp < (file_a.timestamp + offset)):
         temp_group.add(file_b)
         list.remove(file_b)

   groups.add(temp_group)

（好吧，代码更复杂，但这是主要的想法）

这显然不起作用，因为我在循环期间修改列表，并发生奇怪的事情：）

我认为我必须使用'list'副本作为循环，但是，这也不起作用：

for file_a in list[:]:
   temp_group = group()
   temp_group.add(file_a)
   list.remove(file_a)
   for file_b in list[:]:
      if (file_b.timestamp < (file_a.timestamp + offset)):
         temp_group.add(file_b)
         list.remove(file_b)

   groups.add(temp_group)

嗯..我知道我可以在不删除列表中的元素的情况下执行此操作，但是我需要标记已经“处理”的元素，并且我需要每次都检查它们 - 这是速度惩罚。< / p>

有人可以给我一些关于如何以最快/最好的方式完成这项工作的建议吗？

谢谢，

亚历

编辑：我找到了另一个解决方案，但并没有完全回答这个问题，但这正是我实际需要的（我以这种方式提出问题的错误）。我在这里发布这个，因为它可以帮助某人在Python中查找循环遍历列表的相关问题。

它可能不是最快的（考虑到列表中“传递”的数量），但理解和实现起来非常简单，并且不需要对列表进行排序。

我避免排序的原因是它可能需要更多时间，因为在我制作第一组组之后，其中一些组将被“锁定”，未锁定的组将被“解散”，并且使用不同的时间偏移重新分组。（当解散组时，文件顺序可能会更改，并且它们将需要再次排序）。

无论如何，解决方案是自己控制循环索引。如果我从列表中删除一个文件，我跳过增加索引（例如：当我删除索引“3”时，前一个索引“4”现在是“3”，我不想增加循环计数器，因为我会跳过它）。如果在那次迭代中我没有删除任何项目，那么索引会正常增加。这是代码（有一些额外的东西;忽略所有'桶'的东西）：

def regroup(self, time_offset):
    #create list of files to be used for regrouping
    regroup_files_list = []

    if len(self.groups) == 0:
        #on first 'regroup', we start with a copy of jpeg_list, so that we do not change it further on
        regroup_files_list = copy.copy(self.jpeg_list) 

    else:
        i = 0
        while True:
            try:
                group = self.groups[i]
            except IndexError:
                break

            if group.is_locked == False:
                regroup_files_list.extend(group)                    
                self.groups.remove(group)
                continue
            else:
                i += 1

    bucket_group = FilesGroup()
    bucket_group.name = c_bucket_group_name

    while len(regroup_files_list) > 0: #we create groups until there are no files left
        file_a = regroup_files_list[0]
        regroup_files_list.remove(file_a)

        temp_group = FilesGroup()
        temp_group.start_time = file_a._iso_time
        temp_group.add(file_a)

        #manually manage the list index when iterating for file_b, because we're removing files
        i = 0

        while True:
            try:
                file_b = regroup_files_list[i]
            except IndexError:
                break

            timediff = file_a._iso_time - file_b._iso_time              
            if timediff.days < 0 or timediff.seconds < 0:
                timediff = file_b._iso_time - file_a._iso_time

            if timediff < time_offset:
                temp_group.add(file_b)
                regroup_files_list.remove(file_b)
                continue # :D we reuse the old position, because all elements were shifted to the left

            else:
                i += 1 #the index is increased normally

        self.groups.append(temp_group)

        #move files to the bucket group, if the temp group is too small
        if c_bucket_group_enabled == True:                    
            if len(temp_group) < c_bucket_group_min_count:
                for file in temp_group:
                    bucket_group.add(file)
                    temp_group.remove(file)    
            else:
                self.groups.append(temp_group)      

    if len(bucket_group) > 0:
        self.groups.append(bucket_group)

Answer 1

一个简单的解决方案，通过对列表进行排序然后使用生成器来创建组：

def time_offsets(files, offset):

   files = sorted(files, key=lambda x:x.timestamp)

   group = []   
   timestamp = 0

   for f in files:
      if f.timestamp < timestamp + offset:
         group.append(f)
      else:
         yield group
         timestamp = f.timestamp
         group = [timestamp]
   else:
      yield group

# Now you can do this...
for group in time_offsets(files, 86400):
   print group

这是一个完整的脚本，你可以运行来测试：

class File:
   def __init__(self, timestamp):
      self.timestamp = timestamp

   def __repr__(self):
      return "File: <%d>" % self.timestamp

def gen_files(num=100):
   import random
   files = []
   for i in range(num):
      timestamp = random.randint(0,1000000)
      files.append(File(timestamp))

   return files


def time_offsets(files, offset):

   files = sorted(files, key=lambda x:x.timestamp)

   group = []   
   timestamp = 0

   for f in files:
      if f.timestamp < timestamp + offset:
         group.append(f)
      else:
         yield group
         timestamp = f.timestamp
         group = [timestamp]
   else:
      yield group

# Now you can do this to group files by day (assuming timestamp in seconds)
files = gen_files()
for group in time_offsets(files, 86400):
   print group

Answer 2

我能想到的最佳解决方案是O(n log n)。

listA = getListOfFiles()
listB = stableMergesort(listA, lambda el: el.timestamp)
listC = groupAdjacentElementsByTimestampRange(listB, offset)

请注意，groupAdjacentElementsByTimestampRange为O(n)。

Answer 3

我不确定你要做什么 - 在我看来，列表的顺序会影响分组，但你现有的代码可以修改为这样工作。

#This is O(n^2)
while lst:
    file_a=lst.pop()
    temp_group = group()
    temp_group.add(file_a)
    while lst
        file_b=lst[-1] 
        if (file_b.timestamp < (file_a.timestamp + offset)):
            temp_group.add(lst.pop())
    groups.add(temp_group)

该组是否必须从file_a.timestamp开始？

# This is O(n)
from collections import defaultdict
groups=defaultdict(list)  # This is why you shouldn't use `list` as a variable name
for item in lst:
    groups[item.timestamp/offset].append(item)

更简单的方法来切入具有相似时间戳的组

单个列表中最快的嵌套循环（删除或不删除元素）

3 个答案:

一个简单的解决方案，通过对列表进行排序然后使用生成器来创建组：

这是一个完整的脚本，你可以运行来测试：