获取文本文件的第一行和最后一行的最有效方法是什么？

Question

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

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

Answer 1

from os import SEEK_END, SEEK_CUR

def readlast(f):
    try:
        f.seek(-2, SEEK_END)       # Jump to the second last byte.
        while f.read(1) != b"\n":  #  Until newline is found ...
            f.seek(-2, SEEK_CUR)   #  ... jump back, over the read byte plus one.
    except OSError:                # Reached begginning of File
        f.seek(0)                  #  Set cursor to beginning of file as well.
    return f.read()                # Read all data from this point on.
        
with open(path, "rb") as f:
    first = f.readline()
    last  = readlast(f)

使用 seek 时 格式为 fseek(offset,whence=0)

引用自docs.python.org：

将流位置更改为给定的字节偏移量。 offset 是相对于 wherece 指示的位置来解释的。来源的默认值为 SEEK_SET。其值是：

• SEEK_SET 或 0 = 流的开始（默认）；偏移量应为零或正数
• SEEK_CUR 或 1 = 当前流位置；偏移量可能为负
• SEEK_END 或 2 = 流结束；偏移量通常为负

奔腾搜索（2.7+）

from collections import deque
from os import SEEK_CUR, SEEK_END

def readlast(f, d = b'\n'):
    """"readlast(f: io.IOBase, d: bytes = b'\n') -> bytes

    Return the last segment of file `f`, containing data segments separated by
    `d`.
    """
    arr = deque(); step = 1; pos = -1
    try:
        # Seek to last byte of file, save it to arr as to not check for newline.
        pos = f.seek(-1, SEEK_END) 
        arr.appendleft(f.read())
        # Seek past the byte read, plus one to use as the first segment.
        pos = f.seek(-2, SEEK_END) 
        seg = f.read(1)
        # Break when 'd' occurs, store index of the rightmost match in 'i'.
        while seg.rfind(d) == -1:
            # Store segments with no b'\n' in a memory-efficient 'deque'.
            arr.appendleft(seg)
            # Step back in file, past the bytes just read plus twice that.
            pos = f.seek(-step*3, SEEK_CUR)
            # Read new segment, twice as big as the one read previous iteration.
            step *= 2
            seg = f.read(step)
        # Ignore the characters up to 'i', and the triggering newline character.
        arr.appendleft(seg[seg.rfind(d)+1:])
    except OSError: 
        # Reached beginning of file. Read remaining data and check for newline.
        f.seek(0)
        seg = f.read(pos)
        arr.appendleft(seg[seg.rfind(d)+1:])
    return b"".join(arr)

我可能会选择一个利用今天指数增长步长的函数，因此在这里添加了这样一个示例，并将其与原始答案放在一起（暂时）。

除了多字节分隔符和以文本模式打开的文件之外，它可以很好地处理边缘情况（有关处理这些情况的示例，请参阅“边缘情况”）。

用法：

f.write(b'X\nY\nZ\n'); f.seek(0)
assert readlast(f) == b'Z\n'

f.write(b'\n\n'; f.seek(0)
assert readlast(f) == b'\n'

边缘情况（2.7+）

我没有编辑原始答案，因为这个问题专门要求效率，以及尊重以前的赞成票。

该版本解决了多年来提出的所有评论和问题，同时保留了逻辑和向后兼容性（以可读性为代价）。

在撰写本文时提出和解决的问题是：

• 解析空文件时返回空字符串，请参见 Loïc 的评论。
• 未找到分隔符时返回所有内容，在 LazyLeopard 的评论。
• 避免相对偏移以支持文本模式，在 AnotherParker 的评论。
• UTF16/UTF32 hack，在 评论，作者：Pietro Battiston。

还支持多字节分隔符。

from os import SEEK_CUR, SEEK_END

def _readlast__bytes(f, sep, size, step):
    # Point cursor 'size' + 'step' bytes away from the end of the file.
    o = f.seek(0 - size - step, SEEK_END)
    # Step 'step' bytes each iteration, halt when 'sep' occurs.
    while f.read(size) != sep:
        f.seek(0 - size - step, SEEK_CUR)

def _readlast__text(f, sep, size, step):
    # Text mode, same principle but without the use of relative offsets.
    o = f.seek(0, SEEK_END)
    o = f.seek(o - size - step)
    while f.read(size) != sep:
        o = f.seek(o - step)

def readlast(f, sep, fixed = False):
    """readlast(f: io.BaseIO, sep: bytes|str, fixed: bool = False) -> bytes|str

    Return the last segment of file `f`, containing data segments separated by
    `sep`.

    Set `fixed` to True when parsing UTF-32 or UTF-16 encoded data (don't forget
    to pass the correct delimiter) in files opened in byte mode.
    """
    size = len(sep)
    step = len(sep) if (fixed is True) else (fixed or 1)
    step = size if fixed else 1
    if not size:
        raise ValueError("Zero-length separator.")
    try:
        if 'b' in f.mode:
            # Process file opened in byte mode.
            _readlast__bytes(f, sep, size, step)
        else:
            # Process file opened in text mode.
            _readlast__text(f, sep, size, step)
    except (OSError, ValueError): 
        # Beginning of file reached.
        f.seek(0, SEEK_SET)
    return f.read()

用法：

f.write("X\nY\nZ\n".encode('utf32'); f.seek(0)
assert readlast(f, "\n".encode('utf32')[4:]) == "Z\n"

f.write(b'X<br>Y</br>'; f.seek(0)
assert readlast(f, b'<br>', fixed=False) == "Y</br>"

用于与此答案进行比较的效率

代码（最受支持的答案的优化版本[在发布时]）：

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.

结果：

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

“每个 1-2 百万行”，正如问题所述，当然会增加差异< em>还有很多。

Answer 2

io 模块的文档

with open(fname, 'rb') as fh:
    first = next(fh).decode()

    fh.seek(-1024, 2)
    last = fh.readlines()[-1].decode()

这里的变量值为 1024：它代表平均字符串长度。我仅选择 1024 作为示例。如果您估计了平均行长度，则可以使用该值乘以 2。

由于您不知道行长度的可能上限，因此显而易见的解决方案是循环遍历文件：

for line in fh:
    pass
last = line

您不需要如果你想处理二进制标志，你可以使用open(fname)。

预计到达时间：由于您有许多文件需要处理，因此您可以使用 random.sample 创建数十个文件的示例，并对它们运行此代码以确定文件的长度最后一行。位置偏移的先验值较大（假设为 1 MB）。这将帮助您估计完整运行的价值。

Answer 3

这是 SilentGhost 答案的修改版本，可以满足您的需求。

with open(fname, 'rb') as fh:
    first = next(fh)
    offs = -100
    while True:
        fh.seek(offs, 2)
        lines = fh.readlines()
        if len(lines)>1:
            last = lines[-1]
            break
        offs *= 2
    print first
    print last

这里不需要线路长度的上限。

Answer 4

你会使用unix命令吗？我认为使用 head -1 和 tail -n 1 可能是最有效的方法。或者，您可以使用简单的 fid.readline() 来获取第一行和 fid.readlines()[-1]，但这可能会占用太多内存。

Answer 5

这是我的解决方案，也兼容Python3。它也管理边界情况，但它缺少 utf-16 支持：

def tail(filepath):
    """
    @author Marco Sulla ([email protected])
    @date May 31, 2016
    """

    try:
        filepath.is_file
        fp = str(filepath)
    except AttributeError:
        fp = filepath

    with open(fp, "rb") as f:
        size = os.stat(fp).st_size
        start_pos = 0 if size - 1 < 0 else size - 1

        if start_pos != 0:
            f.seek(start_pos)
            char = f.read(1)

            if char == b"\n":
                start_pos -= 1
                f.seek(start_pos)

            if start_pos == 0:
                f.seek(start_pos)
            else:
                char = ""

                for pos in range(start_pos, -1, -1):
                    f.seek(pos)

                    char = f.read(1)

                    if char == b"\n":
                        break

        return f.readline()

它的灵感来自于 Trasp 的回答 和 另一个帕克的评论< /a>.

Answer 6

首先以读取模式打开文件。然后使用 readlines() 方法逐行读取。所有行存储在列表中。现在您可以使用列表切片来获取文件的第一行和最后一行。

    a=open('file.txt','rb')
    lines = a.readlines()
    if lines:
        first_line = lines[:1]
        last_line = lines[-1]

Answer 7

w=open(file.txt, 'r')
print ('first line is : ',w.readline())
for line in w:  
    x= line
print ('last line is : ',x)
w.close()

for 循环遍历各行，x 获取最终迭代的最后一行。

Answer 8

with open("myfile.txt") as f:
    lines = f.readlines()
    first_row = lines[0]
    print first_row
    last_row = lines[-1]
    print last_row

Answer 9

这是 @Trasp 答案的扩展，它具有用于处理只有一行的文件的极端情况的附加逻辑。如果您反复想要读取不断更新的文件的最后一行，处理这种情况可能会很有用。如果没有这个，如果您尝试获取刚刚创建且只有一行的文件的最后一行，则会引发 IOError: [Errno 22] Invalid argument 。

def tail(filepath):
    with open(filepath, "rb") as f:
        first = f.readline()      # Read the first line.
        f.seek(-2, 2)             # Jump to the second last byte.
        while f.read(1) != b"\n": # Until EOL is found...
            try:
                f.seek(-2, 1)     # ...jump back the read byte plus one more.
            except IOError:
                f.seek(-1, 1)
                if f.tell() == 0:
                    break
        last = f.readline()       # Read last line.
    return last

Answer 10

没有人提到使用反转：

f=open(file,"r")
r=reversed(f.readlines())
last_line_of_file = r.next()

Answer 11

获取第一行非常简单。对于最后一行，假设您知道行长度的近似上限， os.lseek 从 SEEK_END 中找到倒数第二行结尾，然后readline() 最后一行。

Answer 12

with open(filename, "rb") as f:#Needs to be in binary mode for the seek from the end to work
    first = f.readline()
    if f.read(1) == '':
        return first
    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 the read byte plus one more.
    last = f.readline()  # Read last line.
    return last

上面的答案是上述答案的修改版本，它处理文件中只有一行的情况

Answer 13

如果您只是在寻找方便的小片段并且适合读取整个文件，请考虑deque。

from collections import deque

with open("/path/to/file", "rb+") as f:
    first = f.readline()
    try:
        last = deque(f, 1)[0]
    except IndexError:
        last = ""
        

将文件对象 f 传递给 deque 将导致 io 库中的内置函数将流拆分为单独的行，而 deque 将最后一行保留在内存中。