如何从 Python 中的文件一次读取一个字符？

Question

谁能告诉我该怎么做？

Answer 1

with open(filename) as f:
  while True:
    c = f.read(1)
    if not c:
      print "End of file"
      break
    print "Read a character:", c

Answer 2

首先，打开一个文件：

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

这会遍历文件中的每一行，然后是该行中的每个字符。

Answer 3

我喜欢公认的答案：它简单明了，可以完成工作。我还想提供一个替代实现：

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 __name__ == "__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))

我建议的代码与您接受的答案基本相同：从文件中读取给定数量的字节。不同之处在于它首先读取一大块数据（4006 是 X86 的一个很好的默认值，但您可能想尝试 1024 或 8192；您的页面大小的任意倍数），然后它产生该块中的字符 one减一。

对于较大的文件，我提供的代码可能会更快。以the entire text of War and Peace, by Tolstoy 为例。这些是我的计时结果（Mac Book Pro 使用 OS X 10.7.4；so.py 是我给我粘贴的代码起的名字）：

$ 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

现在：不要将4096 的缓冲区大小作为普遍真理；看看我得到的不同大小的结果（缓冲区大小（字节）与墙时间（秒））：

   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 

如您所见，您可以更早地开始看到收益（而且我的时间安排可能非常不准确）；缓冲区大小是性能和内存之间的权衡。默认值 4096 只是一个合理的选择，但一如既往地先测量。

Answer 4

只是：

myfile = open(filename)
onecharacter = myfile.read(1)

Answer 5

Python 本身可以在交互模式下帮助您：

>>> 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.

Answer 6

我今天在看 Raymond Hettinger 的 Transforming Code into Beautiful, Idiomatic Python 时学到了一个新的成语：

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) 

Answer 7

只读一个字符

f.read(1)

Answer 8

这也可以：

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

它遍历文件中的每一行以及每一行中的每个字符。

（请注意，这篇文章现在看起来与高度赞成的答案非常相似，但在撰写本文时并非如此。）

Answer 9

Python 3.8+ 的最佳答案：

with open(path, encoding="utf-8") as f:
    while c := f.read(1):
        do_my_thing(c)

您可能希望指定 utf-8 并避免使用平台编码。我选择在这里这样做。

功能 - Python 3.8+：

def stream_file_chars(path: str):
    with open(path) as f:
        while c := f.read(1):
            yield c

函数 - Python

def stream_file_chars(path: str):
    with open(path, encoding="utf-8") as f:
        while True:
            c = f.read(1)
            if c == "":
                break
            yield c

功能——pathlib + 文档：

from pathlib import Path
from typing import Union, Generator

def stream_file_chars(path: Union[str, Path]) -> Generator[str, None, None]:
    """Streams characters from a file."""
    with Path(path).open(encoding="utf-8") as f:
        while (c := f.read(1)) != "":
            yield c

Answer 10

你应该试试f.read(1)，这绝对是正确的，也是正确的做法。

Answer 11

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"

Answer 12

做一个补充， 如果您正在读取包含非常大的行的文件，这可能会破坏您的记忆，您可以考虑将它们读入缓冲区然后产生每个字符

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 __name__ == "__main__":
    for word in read_char('./very_large_file.txt'):
        process(char)

Answer 13

os.system("stty -icanon -echo")
while True:
    raw_c = sys.stdin.buffer.peek()
    c = sys.stdin.read(1)
    print(f"Char: {c}")

Answer 14

#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)