将行写入文件的正确方法是什么？

问题描述：

如何在现代 Python 中将一行写入文件？我听说这已被弃用：

print >>f, "hi there"

另外，`"
"它适用于所有平台吗，还是我应该"
"`在 Windows 上使用？

解决方案 1：

这应该很简单：

with open('somefile.txt', 'a') as the_file:
    the_file.write('Hello
')

来自文档：

os.linesep在文本模式（默认）下打开文件时不要将其用作行终止符；`'
'`在所有平台上都使用单个终止符。

一些有用的读物​​：

• 声明with​

• open()

  • 'a'用于附加，或使用

  • 'w'用截断方式书写

• os（特别os.linesep）

解决方案 2：

您应该使用print()自 Python 2.6+ 以来可用的函数

from __future__ import print_function  # Only needed for Python 2
print("hi there", file=f)

对于 Python 3，您不需要import，因为该 print()函数是默认的。

Python 3 中的替代方法是使用：

with open('myfile', 'w') as f:
    f.write('hi there
')  # python will convert 
 to os.linesep

引用Python 文档中有关换行符的内容：

当将输出写入流时，如果newline为None，`'

'则写入的任何字符都将转换为系统默认的行分隔符 。os.linesep如果*newline*为''或'
'，则不会进行任何转换。如果*newline*是任何其他合法值，则'
'`写入的任何字符都将转换为给定的字符串。

另请参阅：读取和写入文件 - Python 教程

解决方案 3：

Python 文档推荐这种方式：

with open('file_to_write', 'w') as f:
    f.write('file contents
')

所以我通常这样做

来自docs.python.org的声明：

处理文件对象时使用“with”关键字是一种很好的做法。这样做的好处是，即使在过程中出现异常，文件在其套件完成后也会被正确关闭。它也比编写等效的 try-finally 块短得多。

解决方案 4：

关于os.linesep：

以下是 Windows 上未经编辑的 Python 2.7.1 解释器会话：

Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.linesep
'
'
>>> f = open('myfile','w')
>>> f.write('hi there
')
>>> f.write('hi there' + os.linesep) # same result as previous line ?????????
>>> f.close()
>>> open('myfile', 'rb').read()
'hi there
hi there

'
>>>

在 Windows 上：

正如预期的那样， os.linesep不会产生与 相同的结果`'
'。它不可能产生相同的结果。'hi there' + os.linesep相当于'hi there
'，但**不**相当于'hi there
'`。

**就是这么简单：使用`
`which 将自动转换为 os.linesep。**自从 Python 首次移植到 Windows 以来，它就一直这么简单。

在非 Windows 系统上使用 os.linesep 是没有意义的，并且它会在 Windows 上产生错误的结果。

不要使用 os.linesep！

解决方案 5：

我不认为存在“正确”的方法。

我会用：

with open('myfile', 'a') as f:
    f.write('hi there
')

纪念蒂姆·托迪 (Tim Toady)。

解决方案 6：

在 Python 3 中它是一个函数，但在 Python 2 中你可以将其添加到源文件的顶部：

from __future__ import print_function

然后你

print("hi there", file=f)

解决方案 7：

从 3.5 开始您也可以使用以下方法pathlib实现此目的：

Path.write_text(data, encoding=None, errors=None)

以文本模式打开指向的文件，向其中写入数据，然后关闭文件：

import pathlib

pathlib.Path('textfile.txt').write_text('content')

解决方案 8：

如果您要写入大量数据，并且速度是一个问题，那么您可能应该选择。我做了一个快速的速度比较，它比执行大量写入时f.write(...)要快得多。print(..., file=f)

import time    

start = start = time.time()
with open("test.txt", 'w') as f:
    for i in range(10000000):
        # print('This is a speed test', file=f)
        # f.write('This is a speed test
')
end = time.time()
print(end - start)

在我的计算机上平均write完成时间为 2.45 秒，而在我的计算机上则print花费了大约 4 倍的时间（9.76 秒）。话虽如此，在大多数实际情况下，这不会成为问题。

如果您选择使用，print(..., file=f)您可能会发现有时您会想要隐藏换行符，或者用其他内容替换它。这可以通过设置可选end参数来实现，例如；

with open("test", 'w') as f:
    print('Foo1,', file=f, end='')
    print('Foo2,', file=f, end='')
    print('Foo3', file=f)

无论您选择哪种方式，我都建议您使用，with因为它使代码更易于阅读。

更新：这种性能差异是由于write具有高度缓冲并且在实际写入磁盘之前返回（请参阅此答案），而print（可能）使用行缓冲。对此的一个简单测试是检查长写入的性能，其中行缓冲的缺点（就速度而言）不太明显。

start = start = time.time()
long_line = 'This is a speed test' * 100
with open("test.txt", 'w') as f:
    for i in range(1000000):
        # print(long_line, file=f)
        # f.write(long_line + '
')
end = time.time()

print(end - start, "s")

现在，性能差异变得不那么明显了，平均时间为 2.20 秒，write而 为 3.10 秒print。如果您需要连接一串字符串才能获得这么长的行，性能就会受到影响，因此print更高效的用例有点少见。

解决方案 9：

当您说“行”时，它表示一些以“\n”字符结尾的序列化字符。行应该在某个点处为最后一个，因此我们应该在每行末尾考虑“\n”。以下是解决方案：

with open('YOURFILE.txt', 'a') as the_file:
    the_file.write("Hello")

在追加模式下，每次写入后光标都会移动到新行，如果要使用w模式，则应`
在函数末尾添加字符write()`：

the_file.write("Hello
")

解决方案 10：

如果您不想自己使用write()或writelines()以及用换行符连接字符串，则可以将所有行传递给print()，并将换行符分隔符和文件句柄作为关键字参数。此代码段假定您的字符串没有尾随换行符。

print(line1, line2, sep="
", file=f)

您不需要在末尾添加特殊的换行符，因为print()它已经为您完成了。

如果列表中有任意数量的行，则可以使用列表扩展将它们全部传递给print()。

lines = ["The Quick Brown Fox", "Lorem Ipsum"]
print(*lines, sep="
", file=f)

`"
"在 Windows 上用作分隔符是可以的，因为print()它也会自动将其转换为 Windows CRLF 换行符 ( "
"`)。

解决方案 11：

如果您希望在列表中插入每行具有格式的项目，则可以这样开始：

with open('somefile.txt', 'a') as the_file:
    for item in items:
        the_file.write(f"{item}
")

解决方案 12：

还可以io如下使用该模块：

import io
my_string = "hi there"

with io.open("output_file.txt", mode='w', encoding='utf-8') as f:
    f.write(my_string)

解决方案 13：

当我需要大量编写新行时，我会定义一个使用print函数的 lambda：

out = open(file_name, 'w')
fwl = lambda *x, **y: print(*x, **y, file=out) # FileWriteLine
fwl('Hi')

这种方法的好处是它可以利用该print函数提供的所有特性。

更新：正如Georgy在评论部分提到的，可以使用partial以下功能进一步改进这个想法：

from functools import partial
fwl = partial(print, file=out)

恕我直言，这是一种更实用且更少神秘性的方法。

解决方案 14：

要在 Flask 中的文件中写入文本，可以使用：

filehandle = open("text.txt", "w")
filebuffer = ["hi","welcome","yes yes welcome"]
filehandle.writelines(filebuffer)
filehandle.close()

解决方案 15：

您也可以尝试filewriter

pip install filewriter

from filewriter import Writer

Writer(filename='my_file', ext='txt') << ["row 1 hi there", "row 2"]

写入my_file.txt

采用可迭代对象或具有支持的对象__str__。

解决方案 16：

with open('sample.txt', 'a') as f:
    f.write('Hello')
    f.write('
')

在末尾插入f.write('\n')

解决方案 17：

因为其他人已经回答了如何做到这一点，所以我将逐行回答它是如何发生的。

with FileOpenerCM('file.txt') as fp: # is equal to "with open('file.txt') as fp:"
      fp.write('dummy text')

这就是所谓的context manager，任何带有with块的东西都是上下文管理器。让我们看看这在幕后是如何发生的。

class FileOpenerCM:
     def __init__(self, file, mode='w'):
         self.file = open(file, mode)
      
     def __enter__(self):
          return self.file
      
     def __exit__(self, exc_type, exc_value, exc_traceback):
         self.file.close()

第一个方法__init__是（众所周知）对象的初始化方法。每当创建一个对象时obj.__init__肯定会调用该方法。这就是放置所有 init 代码的地方。

第二种方法__enter__有点有趣。有些人可能没有看到它，因为它是上下文管理器的特定方法。它返回的是关键字后要分配给变量的值as。在我们的例子中，fp。

最后一种方法是捕获错误后或代码退出 with 块时运行的方法。exc_type、exc_value、exc_traceback变量是保存 with 块内发生的错误值的变量。例如，

exc_type: TypeError
exc_value: unsupported operand type(s) for +: 'int' and 'str
exc_traceback: <traceback object at 0x6af8ee10bc4d>

从前两个变量中，您可以获得足够的有关错误的信息。老实说，我不知道第三个变量的用途，但对我来说，前两个就足够了。如果您想对上下文管理器进行更多研究，您当然可以这样做，并注意编写类并不是编写上下文管理器的唯一方法。使用contextlib，您也可以通过函数（实际上是生成器）编写上下文管理器。这完全取决于您自己。您当然可以尝试使用 contextlib 的生成器函数，但正如我所见，类要干净得多。