用python删除文件中的最后一行

相关文章推荐

爱搭讪的消炎药 · 使用 Python 进行 IP 地址转换 - · 6 天前 ·

腼腆的柠檬 · python ...· 6 天前 ·

有情有义的大白菜 · python ...· 6 天前 ·

完美的馒头 · python QTreeWidget ...· 3 天前 ·

失眠的烤红薯 · python qt textBrowser ...· 昨天 ·

怕考试的日记本 · Python字典你必须知道的用法系列 - ...· 7 月前 ·

聪明伶俐的葫芦 · bootstrap 的显示和隐藏 - ...· 1 年前 ·

瘦瘦的马克杯 · c# - XML Error: There ...· 1 年前 ·

面冷心慈的红酒 · edge 开发者模式-掘金· 1 年前 ·

怕老婆的手套 · 我可以在创建InputStream之后立即关 ...· 1 年前 ·

countLines = len(file.readlines())

5 个评论

Peter Hansen ：

你是想从磁盘上的文件中删除这一行吗？如果是这样，请确保你明白，从文件系统的角度来看，文件是没有 "行 "的。行是程序员和程序的一种惯例。你所看到的 "行 "是在许多其他字节中间的某个地方的一个字节序列。要删除最后的 "行"，你可以在该行的第一个字符对应的字节处截断文件。这并不难（你只需要找到它），但如果涉及的文件没有多少兆字节大小，就没有什么意义了。

FogleBird ：

如果最后一行是空行怎么办？

torger ：

最后一行不是空白。我用另一个python片段（来自google）删除了所有空行。

torger ：

?文件中没有空行？上面的例子是你应该看的，没有别的。最后一行是我需要删除的内容。为什么要居高临下？草莓的回答让我几乎明白了。

torger ：

有问题的文件不在内存中--它是如上的。

python

text

line

torger

发布于 2009-12-10

10 个回答

发布于 2009-12-10

已采纳

0 人赞同

因为我经常处理许多千兆字节的文件，答案中提到的循环播放对我来说并不奏效。我使用的解决方案。

with open(sys.argv[1], "r+", encoding = "utf-8") as file:
    # Move the pointer (similar to a cursor in a text editor) to the end of the file
    file.seek(0, os.SEEK_END)
    # This code means the following code skips the very last character in the file -
    # i.e. in the case the last line is null we delete the last line
    # and the penultimate one
    pos = file.tell() - 1
    # Read each character in the file one at a time from the penultimate
    # character going backwards, searching for a newline character
    # If we find a new line, exit the search
    while pos > 0 and file.read(1) != "\n":
        pos -= 1
        file.seek(pos, os.SEEK_SET)
    # So long as we're not at the start of the file, delete all the characters ahead
    # of this position
    if pos > 0:
        file.seek(pos, os.SEEK_SET)
        file.truncate()


         
          这是最好的答案。使用 "with "语句来节省一行:)


         
          在对mac和windows上使用的文件使用这种方法时，我遇到了一些兼容性问题（使用Py3），因为在内部Mac使用的行结束符与Windows不同（Windows使用2：cr和lf）。解决办法是以二进制读取模式（"rb+"）打开文件，并搜索二进制换行符b"\n"。


       0
       
       人赞同


        
         你可以使用上述代码，然后：-
        
        lines = file.readlines()
lines = lines[:-1]
这将给你一个包含所有行的数组，但最后一行除外。


         
          
           这对大文件来说是否能很好地工作？例如，数千行的文件？


         
          
           Paul McMillan
          
          ：


         
          
           对于大于一两兆字节的文件，它可能不好用。这要看你对 "好 "的定义。对于任何桌面使用的几千行文件来说，它应该是完全没问题的。


         
          
           嗯--一两秒钟之内。


         
          
           就没有其他办法直接删除某一行吗？还是用数组的方式来处理？


         
          
           Laurence Gonsalves
          
          ：


         
          
           Nazarius:没有任何方法可以删除一个特定的行。但是你可以截断一个文件或对其进行追加。既然你想删除最后一行，你可以直接截断。


        
         
          这并没有使用python，但如果这是你唯一想要的任务，python是错误的工具。你可以使用标准的*nix工具
          
           head
          
          ，并运行
         
         head -n-1 filename > newfile
这将把文件名中除最后一行以外的所有内容复制到newfile。


         
          
           
            我想保持它的跨平台性--因此问题中提到了通过python。


         
          
           
            Emil Stenström
           
           ：


         
          
           
            这在Mac OSX上不起作用：头：非法行数 -- 1


         
          
           
            喜欢它，漂亮而简单。我对linux的解决方案很满意 :D


         
          
           
            Marie Hoffmann
           
           ：


         
          
           
            我怀疑带有
            
             seek
            
            的Python版本对内存的需求较小，因此更适合于非常大的文件，而
            
             head
            
            是一个很好的单行代码，但涉及读取和复制几乎整个文件。


        
         
          
           假设你必须在Python中这样做，而且你有一个足够大的文件，列表切分还不够，你可以在文件上一次性完成。
          
          last_line = None
for line in file:
    if last_line:
        print last_line # or write to a file, call a function, etc.
    last_line = line
这不是世界上最优雅的代码，但它能完成工作。
基本上，它通过last_line变量对文件中的每一行进行缓冲，每次迭代都会输出前一次迭代的行。


        
         
          
           
            
            
             Laurence Gonsalves
            
           
           
            发布于
            
            2009-12-10


        
         
          
           
            On systems where
            
             file.truncate()
            
            works, you could do something like this:
           
           file = open('file.txt', 'rb')
pos = next = 0
for line in file:
  pos = next # position of beginning of this line
  next += len(line) # compute position of beginning of next line
file = open('file.txt', 'ab')
file.truncate(pos)
根据我的测试，file.tell()在按行读取时不起作用，可能是由于缓冲区的问题使其混淆。这就是为什么要把行的长度加起来来计算位置的原因。请注意，这只在行的分隔符以'/n'结尾的系统上起作用。


         
          
           
            
             
              Peter Hansen
             
             ：


         
          
           
            
             
              在一个使用多个字符表示 "行结束 "的平台上非常危险......如Windows。


         
          
           
            
             
              Laurence Gonsalves
             
             ：


         
          
           
            
             
              说得好。(这实际上是我最初打算使用tell()的原因，但它不起作用。)在这种情况下，以二进制模式打开文件应该可以。


         
          
           
            
             
              我也会采用截断法，特别是对于大文件。


        
         
          
           
            
             here is my solution for linux users:
            
            import os 
file_path = 'test.txt'
os.system('sed -i "$ d" {0}'.format(file_path))
不需要在Python中读取和遍历文件。


         
          
           
            
             
              
               Hossein Kalbasi
              
              ：


         
          
           
            
             
              
               你如何用它来删除文件的
               
                last n
               
               行？


        
         
          
           
            
             
              
              
               Mohammad M. Shahbazi
              
             
             
              发布于
              
              2009-12-10


        
         
          
           
            
             
              Inspiring from previous posts, I propound this:
             
             with open('file_name', 'r+') as f:
  f.seek(0, os.SEEK_END) 
  while f.tell() and f.read(1) != '\n':
    f.seek(-2, os.SEEK_CUR)
  f.truncate()


        
         
          
           
            
             
              
               虽然我没有测试过（请不要因此而讨厌），但我相信有一种更快的方法。这更像是一个C语言的解决方案，但在Python中也很有可能。这也不是Pythonic。我想说的是，这是一个理论。
              
              
               首先，你需要知道该文件的编码。将一个变量设置为该编码中一个字符使用的字节数（在ASCII中为1字节）。
               
                规模
               
               (为什么不呢)。可能会是1个字节的ASCII文件。
              
              
               然后抓取文件的大小，设置
               
                文件大小
               
               to it.
              
              
               假设你有文件的地址（在内存中），在
               
                文件添加
               
               .
              
              
               添加
               
                文件大小
               
               to
               
                文件添加
               
               .
              
              
               Move backwords (increment by -1***规模**), testing each 规模 bytes for a \n (or whatever newline your system uses). When you reach the first \n, you now have the position of the beginning of the first line of the file. Replace \n with \x1a (26, the ASCII for EOF, or whatever that is one your system/with the encoding).
              
              
               无论你需要怎样清理（改变文件大小，触摸文件）。
              
              
               如果这能像我猜想的那样，你会节省很多时间，因为你不需要从头到尾读完整个文件，而是从尾部读。


         
          
           
            
             
              
               
                Peter Hansen
               
               ：


         
          
           
            
             
              
               
                请注意，整个\x1a（又名^Z又名CTRL-Z又名EOF，实际上是ASCII中的SUB）的事情完全是上个世纪的事情......现在很少有文本文件用实际的SUB字符来结束，即使是那些也几乎只限于Windows/DOS系统。  我想还有CPM。


         
          
           
            
             
              
               
                啊，说得好--我不确定它是否还在广泛使用......能否用其他东西来挽救这种技术？


        
         
          
           
            
             
              
               这里有另一种方法，不用把整个文件放入内存中
              
              f=open("file")
for line in f:
    line=line.strip()
    print p
    p=line
f.close()


        
         
          
           
            
             
              
               这里有一个更普遍的节省内存的解决方案，允许跳过最后的'n'行（像
               
                head
               
               命令）。
              
              import collections, fileinput
def head(filename, lines_to_delete=1):
    queue = collections.deque()
    lines_to_delete = max(0, lines_to_delete) 
    for line in fileinput.input(filename, inplace=True, backup='.bak'):
        queue.append(line)
        if lines_to_delete == 0: