Question

客户端通过套接字发送数据。数据被解析，并放入列表中。

这很好用。

有时它包含重复数据，我想用这些数据替换旧数据，所以我.pop（）将其添加到新数据中。

这种方法很好......暂时。

某处有一个减速。我在相当一致的数据量上判断速度。它通过它开始加速并持续大约10分钟左右。在那个时候，它必须经常清除旧的匹配，列表大小大致相同。

然后，控制台成为一个相当缓慢的墙壁，并且删除了欺骗：＆＃34;当它飞过那个数量之前。

因为需要花费更多时间才会将更多内容添加到队列中，并且它将成为一个永无止境的循环，它无法赶上。

当前代码片段：

def QDUmp(): #Runs as a thread
    while 1:
        while not q.empty():

            print q.get()

            XMLdataparse = []
            del XMLdataparse[:]
            XMLdataparse[:] = []
            XMLdataparse = q.get().split('--ListBreaker--')

            if len(XMLdataparse) == 20:

                if "EventText" in XMLdataparse[0]:
                    TheCounter = len(EventTags)-1
                    for Events in reversed(EventTags):
                        try:
                            EventN = EventNames[TheCounter]
                            PlaceN = PlaceNames[TheCounter]
                            TypeN =  BetHorsessToMake[TheCounter]
                            OldTag = EventTags[TheCounter]

                            if EventN == str(XMLdataparse[2]) and PlaceN == str(XMLdataparse[3]) and TypeN == str(XMLdataparse[4]):
                                print "removing dupe: ",TypeN
                                EventTags.pop(TheCounter)
                                EventTimes.pop(TheCounter)
                                EventNames.pop(TheCounter)
                                PlaceNames.pop(TheCounter)

                            TheCounter = TheCounter - 1
                        except:
                            print "problem removing a duplicate result"

                if float(XMLdataparse[6]) > float(XMLdataparse[18]):
                    EventTags.append(XMLdataparse[0])
                    EventTimes.append(XMLdataparse[1])
                    EventNames.append(XMLdataparse[2])
                    PlaceNames.append(XMLdataparse[3])


class ThreadedServer(object):
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.bind((self.host, self.port))

    def listen(self):
        self.sock.listen(5)
        while True:
            client, address = self.sock.accept()
            client.settimeout(60)
            threading.Thread(target = self.listenToClient,args = (client,address)).start()

    def listenToClient(self, client, address):
        size = 1024
        while True:
            try:
                data = client.recv(size)
                if data:
                    try:
                        BigSocketParse = []
                        del BigSocketParse[:]
                        BigSocketParse[:] = []
                        BigSocketParse = data.split('--MarkNew--')

                        print "Putting data in queue"
                        for eachmatch in BigSocketParse:
                            q.put(str(eachmatch))

                    except:
                        print "Unable to parse socket text."

                    #q.put(data)
                    #QCheck.start()
                else:
                    raise error('Client disconnected')
            except:
                client.close()


CheckQ = Thread(target = QDUmp)
CheckQ.start()

ThreadedServer('',1234).listen()

使用--MarkNew--作为分隔符，使用一个更大的套接字发送数据，然后使用--ListBreaker--将其分解为列表部分。也许不是最有效的做事方式，但套接字的大小也大致相同，所以减速必须是我处理清单的方式。

在我的头脑中，它首先没有效率，因为它必须通过整个列表。但我不知道另一种摆脱重复的方法。

对此的任何指示都非常感激。

更新

我找到了一种方法让它处理可能十几个两个条目而不是几百个并比较整个套接字数据而不是每个单独的部分，但是不能完成任务不幸。我必须能够保留单个部件，如果他们是新的并删除重复部件。我无法找到一种不必这样做的方法。

正在考虑多线程。它可能会占用资源，但至少它不会将所有内容都停止，但我开始使用队列的全部原因是没有多个线程同时读取和写入这些列表。

更新＃2：

坚持......

异常处理程序不会移动TheCounter，这意味着它不会正常移动，但是如果它抛出异常，那么无论如何它都会使整个事情失控。这可能解释了当它开始减速时出现的一两个其他错误。

只使用一个列表就可以重做一些事情。

我可以将其更改为一个列表，而不是几个或仅比较一个条目而不是三个，但我发现很难相信这可能是减速的原因。

更新＃3：

将其缩减为仅从一个列表中弹出。将数据写入XML的函数现在首先复制列表，使其工作的时间与队列写入的不同。

这改善了一些事情，但它仍然比我预期的要慢。

Answer 1

我已将其缩减为处理一个列表，而且似乎加快了速度并同时解决了其他一些问题。

我知道它看起来很奇怪，但我认为这和我能够获得它一样高效。

迭代列表队列的Python - 删除带有减速的重复项

1 个答案: