Python TCP套接字recv（1）与recv（n）的效率

Question

I'm building a TCP application which uses a newline \\n to separate messages of unknown length (but typically < 64 bytes). I'm finding this article to be very useful.

Is the best (ie most efficient / fastest) approach to recv one character at a time and check if its a newline or recv a larger buffer and store "leftovers" in the class?

One at a time

def __recv_until_newline(self):
    message = ""
    while True:
        chunk = self.socket.recv(1)
        if chunk == "" or chunk == "\n":
            break
        message += chunk
    return message

Maintain a buffer

def __recv_until_newline(self):
    """ self.__buffer holds previously received message parts"""
    message = self.__buffer
    while True:
        chunk = self.socket.recv(64)
        message += chunk
        if chunk == "" or "\n" in message:
            break

    # something a bit more intelligent than this in reality, but you get the idea
    messages = message.split('\n')
    self.__buffer = "".join([x for x in message[1:]])
    return messages[0]

Answer 1

Getting big chunks is definitely more efficient simply because you are doing less operations. Think about it like this: if you have a message of length 1000, then your loop will fire 1000 times in first case and in second only 16. Performance loss is obvious. Of course this is because of Python, but even on OS level it is more efficient because of the same reason: making 1000 sys calls instad of 16. And scanning string (by the way: you should scan chunk instead of message ) of length 64 is less expensive then 64 calls to recv . That's pretty much it.