我有一个文本文件，每行都包含一个时间戳。我的目标是找到时间范围。所有的时间都是按顺序排列的，所以第一行是最早的时间，最后一行是最晚的时间。我只需要第一行和最后一行。在 python 中获取这些行的最有效方法是什么？

注意:这些文件的长度相对较大，每个大约 1-2 百万行，我必须为数百个文件执行此操作。

最佳答案

要读取文件的第一行和最后一行，您可以...

• 打开文件，...
• ... 使用内置 readline() 读取第一行, ...
• ...寻找(移动光标)到文件末尾，...
• ... 后退一步，直到遇到 EOL (换行符)和...
• ...从那里读取最后一行。

def readlastline(f):
    f.seek(-2, 2)              # Jump to the second last byte.
    while f.read(1) != b"\n":  # Until EOL is found ...
        f.seek(-2, 1)          # ... jump back, over the read byte plus one more.
    return f.read()            # Read all data from this point on.
    
with open(file, "rb") as f:
    first = f.readline()
    last = readlastline(f)

直接跳转到秒最后一个字节，防止尾随换行符导致返回空行*。

每次读取一个字节时，当前偏移量将前移一个，因此每次向后执行两个字节，经过最近读取的字节和下一个要读取的字节。

whence传递给 fseek(offset, whence=0) 的参数表示fseek应寻求职位offset相对于...的字节数

• 0 或 os.SEEK_SET = 文件的开头。
• 1 或 os.SEEK_CUR = 当前位置。
• 2 或 os.SEEK_END = 文件结尾。

* 与大多数应用程序的默认行为一样，包括 print和 echo , 是在写入的每一行附加一个，并且对缺少尾随换行符的行没有影响。

效率

1-2 million lines each and I have to do this for several hundred files.

我对该方法进行了计时，并将其与最佳答案进行了比较。

10k iterations processing a file of 6k lines totalling 200kB: 1.62s vs 6.92s.
100 iterations processing a file of 6k lines totalling 1.3GB: 8.93s vs 86.95.

数百万行会增加差异很多更多。

用于计时的准确代码:

with open(file, "rb") as f:
    first = f.readline()     # Read and store the first line.
    for last in f: pass      # Read all lines, keep final value.

修改

一个更复杂、更难阅读的变体，用于解决此后提出的评论和问题。

• 解析空文件时返回空字符串，由 comment 引发.
• 在未找到分隔符时返回所有内容，由 comment 提出.
• 避免相对偏移以支持 text mode , 由 comment 提出.
• UTF16/UTF32 hack，由 comment 记录.

还增加了对多字节分隔符的支持，readlast(b'X<br>Y', b'<br>', fixed=False) .

请注意，对于大文件，这种变化真的很慢，因为在文本模式下需要非相对偏移。根据您的需要进行修改，或者根本不使用它，因为您最好使用 f.readlines()[-1]以文本模式打开文件。

#!/bin/python3

from os import SEEK_END

def readlast(f, sep, fixed=True):
    r"""Read the last segment from a file-like object.

    :param f: File to read last line from.
    :type  f: file-like object
    :param sep: Segment separator (delimiter).
    :type  sep: bytes, str
    :param fixed: Treat data in ``f`` as a chain of fixed size blocks.
    :type  fixed: bool
    :returns: Last line of file.
    :rtype: bytes, str
    """
    bs   = len(sep)
    step = bs if fixed else 1
    if not bs:
        raise ValueError("Zero-length separator.")
    try:
        o = f.seek(0, SEEK_END)
        o = f.seek(o-bs-step)    # - Ignore trailing delimiter 'sep'.
        while f.read(bs) != sep: # - Until reaching 'sep': Read sep-sized block
            o = f.seek(o-step)   #  and then seek to the block to read next.
    except (OSError,ValueError): # - Beginning of file reached.
        f.seek(0)
    return f.read()

def test_readlast():
    from io import BytesIO, StringIO
    
    # Text mode.
    f = StringIO("first\nlast\n")
    assert readlast(f, "\n") == "last\n"
    
    # Bytes.
    f = BytesIO(b'first|last')
    assert readlast(f, b'|') == b'last'
    
    # Bytes, UTF-8.
    f = BytesIO("X\nY\n".encode("utf-8"))
    assert readlast(f, b'\n').decode() == "Y\n"
    
    # Bytes, UTF-16.
    f = BytesIO("X\nY\n".encode("utf-16"))
    assert readlast(f, b'\n\x00').decode('utf-16') == "Y\n"
  
    # Bytes, UTF-32.
    f = BytesIO("X\nY\n".encode("utf-32"))
    assert readlast(f, b'\n\x00\x00\x00').decode('utf-32') == "Y\n"
    
    # Multichar delimiter.
    f = StringIO("X<br>Y")
    assert readlast(f, "<br>", fixed=False) == "Y"
    
    # Make sure you use the correct delimiters.
    seps = { 'utf8': b'\n', 'utf16': b'\n\x00', 'utf32': b'\n\x00\x00\x00' }
    assert "\n".encode('utf8' )     == seps['utf8']
    assert "\n".encode('utf16')[2:] == seps['utf16']
    assert "\n".encode('utf32')[4:] == seps['utf32']
    
    # Edge cases.
    edges = (
        # Text , Match
        (""    , ""  ), # Empty file, empty string.
        ("X"   , "X" ), # No delimiter, full content.
        ("\n"  , "\n"),
        ("\n\n", "\n"),
        # UTF16/32 encoded U+270A (b"\n\x00\n'\n\x00"/utf16)
        (b'\n\xe2\x9c\x8a\n'.decode(), b'\xe2\x9c\x8a\n'.decode()),
    )
    for txt, match in edges:
        for enc,sep in seps.items():
            assert readlast(BytesIO(txt.encode(enc)), sep).decode(enc) == match

if __name__ == "__main__":
    import sys
    for path in sys.argv[1:]:
        with open(path) as f:
            print(f.readline()    , end="")
            print(readlast(f,"\n"), end="")

关于python - 获取文本文件的第一行和最后一行的最有效方法是什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3346430/