web-dev-qa-db-fra.com

Comment lire un seul caractère à la fois à partir d'un fichier en Python?

Quelqu'un peut-il me dire comment puis-je faire cela?

pythonfile-iocharacter
57
kaushik
with open(filename) as f:
  while True:
    c = f.read(1)
    if not c:
      print "End of file"
      break
    print "Read a character:", c
74
jchl

d'abord ouvrir un fichier: 

with open("filename") as fileobj:
    for line in fileobj:  
       for ch in line: 
           print ch
31
Raj

J'aime la réponse acceptée: elle est simple et fera le travail. J'aimerais également proposer une autre implémentation:

def chunks(filename, buffer_size=4096):
    """Reads `filename` in chunks of `buffer_size` bytes and yields each chunk
    until no more characters can be read; the last chunk will most likely have
    less than `buffer_size` bytes.

    :param str filename: Path to the file
    :param int buffer_size: Buffer size, in bytes (default is 4096)
    :return: Yields chunks of `buffer_size` size until exhausting the file
    :rtype: str

    """
    with open(filename, "rb") as fp:
        chunk = fp.read(buffer_size)
        while chunk:
            yield chunk
            chunk = fp.read(buffer_size)

def chars(filename, buffersize=4096):
    """Yields the contents of file `filename` character-by-character. Warning:
    will only work for encodings where one character is encoded as one byte.

    :param str filename: Path to the file
    :param int buffer_size: Buffer size for the underlying chunks,
    in bytes (default is 4096)
    :return: Yields the contents of `filename` character-by-character.
    :rtype: char

    """
    for chunk in chunks(filename, buffersize):
        for char in chunk:
            yield char

def main(buffersize, filenames):
    """Reads several files character by character and redirects their contents
    to `/dev/null`.

    """
    for filename in filenames:
        with open("/dev/null", "wb") as fp:
            for char in chars(filename, buffersize):
                fp.write(char)

if __== "__main__":
    # Try reading several files varying the buffer size
    import sys
    buffersize = int(sys.argv[1])
    filenames  = sys.argv[2:]
    sys.exit(main(buffersize, filenames))

Le code que je suggère est essentiellement la même idée que votre réponse acceptée: lisez un nombre donné d’octets dans le fichier. La différence est qu’il lit d’abord une bonne quantité de données (4006 est une bonne valeur par défaut pour X86, mais vous pouvez essayer 1024 ou 8192; n’importe quel multiple de la taille de votre page), puis les résultats de cette partie sont renvoyés. par un.

Le code que je présente peut être plus rapide pour les gros fichiers. Prenez, par exemple, le texte entier de Guerre et Paix, de Tolstoï }. Voici les résultats de chronométrage (Mac Book Pro sous OS X 10.7.4; so.py est le nom que j'ai donné au code que j'ai collé):

$ time python so.py 1 2600.txt.utf-8
python so.py 1 2600.txt.utf-8  3.79s user 0.01s system 99% cpu 3.808 total
$ time python so.py 4096 2600.txt.utf-8
python so.py 4096 2600.txt.utf-8  1.31s user 0.01s system 99% cpu 1.318 total

Maintenant: ne prenez pas la taille de la mémoire tampon à 4096 comme une vérité universelle; Regardez les résultats obtenus pour différentes tailles (taille de la mémoire tampon (octets) en fonction du temps passé sur le mur (en secondes)):

   2 2.726 
   4 1.948 
   8 1.693 
  16 1.534 
  32 1.525 
  64 1.398 
 128 1.432 
 256 1.377 
 512 1.347 
1024 1.442 
2048 1.316 
4096 1.318

Comme vous pouvez le constater, vous pouvez commencer à constater des gains plus tôt (et mes horaires sont probablement très imprécis); la taille de la mémoire tampon est un compromis entre performances et mémoire. La valeur par défaut de 4096 n’est qu’un choix raisonnable mais, comme toujours, mesurez d’abord.

14
Escualo

Python lui-même peut vous aider avec ceci, en mode interactif:

>>> help(file.read)
Help on method_descriptor:

read(...)
    read([size]) -> read at most size bytes, returned as a string.

    If the size argument is negative or omitted, read until EOF is reached.
    Notice that when in non-blocking mode, less data than what was requested
    may be returned, even if no size parameter was given.
8
Mattias Nilsson

Juste:

myfile = open(filename)
onecaracter = myfile.read(1)
5
joaquin

J'ai appris un nouveau langage pour cela aujourd'hui en regardant/ Transformer le code en beau python idiomatique :

import functools

with open(filename) as f:
    f_read_ch = functools.partial(f.read, 1)
    for ch in iter(f_read_ch, ''):
        print 'Read a character:', repr(ch)
4
Michael Kropat

Vous devriez essayer f.read(1), ce qui est tout à fait correct et correct.

2
Johan Kotlinski

Il suffit de lire un seul caractère

f.read(1)
2
David Sykes
f = open('hi.txt', 'w')
f.write('0123456789abcdef')
f.close()
f = open('hej.txt', 'r')
f.seek(12)
print f.read(1) # This will read just "c"
0
user1489833

Pour créer un supplément, si vous lisez un fichier contenant une ligne très volumineuse qui risque de vous casser la mémoire, vous pouvez envisager de le lire dans un tampon, puis de renvoyer chaque caractère. 

def read_char(inputfile, buffersize=10240):
    with open(inputfile, 'r') as f:
        while True:
            buf = f.read(buffersize)
            if not buf:
                break
            for char in buf:
                yield char
        yield '' #handle the scene that the file is empty

if __== "__main__":
    for Word in read_char('./very_large_file.txt'):
        process(char)
0
pambda
#reading out the file at once in a list and then printing one-by-one
f=open('file.txt')
for i in list(f.read()):
    print(i)
0
ParagAb

Cela fonctionnera également:

with open("filename") as fileObj:
    for line in fileObj:  
        for ch in line:
            print(ch)

Il parcourt chaque ligne du fichier et chaque caractère de chaque ligne.

0
Pro Q