Tampons Python

Disons que je veux lire une ligne à partir d'une prise, à l'aide de la norme socket module:

def read_line(s):
    ret = ''

    while True:
        c = s.recv(1)

        if c == '\n' or c == '':
            break
        else:
            ret += c

    return ret

Exactement ce qui se passe dans s.recv(1)? Il sera question d'un système d'appel à chaque fois? Je suppose que je devrais ajouter un peu de mise en mémoire tampon, de toute façon:

Pour une meilleure correspondance avec le matériel et le réseau des réalités, la valeur de bufsize doit être relativement petite puissance de 2, par exemple, 4096.

http://docs.python.org/library/socket.html#socket.socket.recv

Mais il ne semble pas facile à écrire efficace et thread-safe de mise en mémoire tampon. Que faire si j'utilise file.readline()?

# does this work well, is it efficiently buffered?
s.makefile().readline()

source d'informationauteur Bastien Léonard | 2009-05-04

  1. 18

    La recv() appel est traité directement par l'appel de la fonction de la bibliothèque C.

    Il permet de bloquer en attente pour la prise des données. En réalité, elle sera simplement laisser le recv() système de blocage d'appel.

    file.readline() est un tampon efficace de mise en œuvre. Il n'est pas thread-safe, car elle suppose que c'est le seul de la lecture du fichier. (Par exemple, par la mise en mémoire tampon à venir d'entrée.)

    Si vous utilisez le fichier de l'objet, à chaque fois read() est appelée avec un argument positif, le code sous-jacent sera recv() seulement la quantité de données demandées, sauf si c'est déjà mises en mémoire tampon.

    Il serait tampon si:

    • vous avait appelé readline(), qui se lit d'un tampon complète

    • la fin de la ligne avant la fin de la mémoire tampon

    Laissant ainsi les données dans la mémoire tampon. Sinon, le tampon est généralement pas trop rempli.

    Le but de la question n'est pas claire. si vous avez besoin de voir si des données sont disponibles, avant la lecture, vous pouvez select() ou définir le socket non bloquante mode avec s.setblocking(False). Ensuite, les lectures de retour à vide, plutôt que de bloquer, si il n'y a pas d'attente de données.

    Êtes-vous à la lecture d'un fichier ou d'une douille avec plusieurs threads? Je mettrais un seul travailleur à la lecture de la douille et de l'alimentation des éléments reçus dans une file d'attente pour un traitement par d'autres threads.

    Suggérons de consulter Python Socket Module de source et Source C qui rend les appels système.

  2. 22

    Si vous êtes concernés par la performance et le contrôle de la prise complètement
    (vous n'êtes pas le passage dans une bibliothèque par exemple), puis essayez de la mise en œuvre de
    votre tampon en Python -- chaîne Python.trouver et chaîne de caractères.split et peut
    être étonnamment rapide.

    def linesplit(socket):
    buffer = socket.recv(4096)
    buffering = True
    while buffering:
        if "\n" in buffer:
            (line, buffer) = buffer.split("\n", 1)
            yield line + "\n"
        else:
            more = socket.recv(4096)
            if not more:
                buffering = False
            else:
                buffer += more
    if buffer:
        yield buffer

    Si vous vous attendez à la charge utile composée de lignes
    qui ne sont pas trop énorme, qui devrait courir assez vite,
    et d'éviter de sauter par de trop nombreuses couches de la fonction
    appels inutilement. Je serais intéressant de savoir
    comment cela se compare à un fichier.readline() ou à l'aide d'une douille.recv(1).

  3. 6
    def buffered_readlines(pull_next_chunk, buf_size=4096):
  """
  pull_next_chunk is callable that should accept one positional argument max_len,
  i.e. socket.recv or file().read and returns string of up to max_len long or
  empty one when nothing left to read.

  >>> for line in buffered_readlines(socket.recv, 16384):
  ...   print line
    ...
  >>> # the following code won't read whole file into memory
  ... # before splitting it into lines like .readlines method
  ... # of file does. Also it won't block until FIFO-file is closed
  ...
  >>> for line in buffered_readlines(open('huge_file').read):
  ...   # process it on per-line basis
        ...
  >>>
  """
  chunks = []
  while True:
    chunk = pull_next_chunk(buf_size)
    if not chunk:
      if chunks:
        yield ''.join(chunks)
      break
    if not '\n' in chunk:
      chunks.append(chunk)
      continue
    chunk = chunk.split('\n')
    if chunks:
      yield ''.join(chunks + [chunk[0]])
    else:
      yield chunk[0]
    for line in chunk[1:-1]:
      yield line
    if chunk[-1]:
      chunks = [chunk[-1]]
    else:
      chunks = []