Maneira correta de escrever linha para arquivo?

Estou acostumado a fazer print >>f, "hi there"

No entanto, parece que print >>está sendo preterido. Qual é a maneira recomendada de fazer a linha acima?

Atualização : Em relação a todas essas respostas com "\n"... isso é universal ou específico para Unix? IE, devo fazer "\r\n"no Windows?

Isso deve ser tão simples quanto:

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

Da documentação:

Não use os.linesepcomo terminador de linha ao gravar arquivos abertos no modo de texto (o padrão); use um único '\ n' em todas as plataformas.

Alguma leitura útil:

• A withdeclaração
• open()
  • 'a' é para acrescentar ou usar
  • 'w' para escrever com truncamento
• os(particularmente os.linesep)

Você deve usar a print()função que está disponível desde o Python 2.6+

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

Para o Python 3, você não precisa do import, pois a print()função é o padrão.

A alternativa seria usar:

f = open('myfile', 'w')
f.write('hi there\n')  # python will convert \n to os.linesep
f.close()  # you can omit in most cases as the destructor will call it

Citando a documentação do Python sobre novas linhas:

Na saída, se newline for None, qualquer '\n'caractere gravado será convertido no separador de linhas padrão do sistema os.linesep. Se for nova linha '', nenhuma tradução ocorrerá. Se nova linha for um dos outros valores legais, qualquer '\n'caractere gravado será convertido para a sequência especificada.

Os documentos python recomendam desta maneira:

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

Então é assim que eu costumo fazer :)

Declaração de docs.python.org :

É uma boa prática usar a palavra-chave 'with' ao lidar com objetos de arquivo. Isso tem a vantagem de o arquivo ser fechado corretamente após a conclusão do conjunto, mesmo que uma exceção seja levantada no caminho. Também é muito mais curto que escrever blocos equivalentes de tentativa e finalmente.

Em relação ao os.linesep:

Aqui está uma sessão exata do intérprete não editada do Python 2.7.1 no Windows:

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
'\r\n'
>>> f = open('myfile','w')
>>> f.write('hi there\n')
>>> f.write('hi there' + os.linesep) # same result as previous line ?????????
>>> f.close()
>>> open('myfile', 'rb').read()
'hi there\r\nhi there\r\r\n'
>>>

No Windows:

Como esperado, o os.linesep NÃO produz o mesmo resultado que '\n'. Não há como produzir o mesmo resultado. 'hi there' + os.linesepé equivalente a 'hi there\r\n', que NÃO é equivalente a 'hi there\n'.

É simples: o uso \nserá traduzido automaticamente para os.linesep. E tem sido tão simples desde a primeira porta do Python para o Windows.

Não faz sentido usar o os.linesep em sistemas não Windows e produz resultados incorretos no Windows.

NÃO USE os.linesep!

Eu não acho que exista uma maneira "correta".

Eu usaria:

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

Em memória de Tim Toady .

No Python 3, é uma função, mas no Python 2 você pode adicioná-lo à parte superior do arquivo de origem:

from __future__ import print_function

Então você faz

print("hi there", file=f)

Se você está escrevendo muitos dados e a velocidade é uma preocupação, provavelmente você deve concordar f.write(...). Fiz uma comparação rápida de velocidade e foi consideravelmente mais rápida do que print(..., file=f)na execução de um grande número de gravações.

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\n')
end = time.time()
print(end - start)

Em média, writeterminei em 2,45s na minha máquina, enquanto printdemorou cerca de 4 vezes mais (9,76s). Dito isto, na maioria dos cenários do mundo real, isso não será um problema.

Se você optar por acompanhá- print(..., file=f)lo, provavelmente descobrirá que deseja suprimir a nova linha de tempos em tempos ou substituí-la por outra. Isso pode ser feito configurando o endparâmetro opcional , por exemplo;

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

Qualquer que seja a maneira que você escolher, sugiro usar, withpois torna o código muito mais fácil de ler.

Atualização : Essa diferença de desempenho é explicada pelo fato de writeser altamente armazenado em buffer e retornar antes que qualquer gravação no disco ocorra (consulte esta resposta ), enquanto print(provavelmente) usa o buffer de linha. Um teste simples para isso seria verificar o desempenho também para gravações longas, onde as desvantagens (em termos de velocidade) do buffer de linha seriam menos pronunciadas.

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 + '\n')
end = time.time()

print(end - start, "s")

A diferença de desempenho agora se torna muito menos acentuada, com um tempo médio de 2,20s para writee 3,10s para print. Se você precisar concatenar printvárias seqüências de caracteres para obter esse desempenho muito longo da linha, os casos de uso em que seria mais eficiente são um pouco raros.

Desde o 3.5, você também pode usar o pathlibpara esse fim:

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

Abra o arquivo apontado no modo de texto, grave dados e feche o arquivo:

import pathlib

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

Quando você disse Linha, significa alguns caracteres serializados que terminam em '\ n'. A linha deve ser a última em algum momento; portanto, devemos considerar '\ n' no final de cada linha. Aqui está a solução:

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

no modo de acréscimo após cada gravação, o cursor se move para a nova linha; se você quiser usar o wmodo, adicione \ncaracteres no final da write()função:

the_file.write("Hello\n")

Pode-se também usar o iomódulo como em:

import io
my_string = "hi there"

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

Para escrever texto em um arquivo no balão, pode ser usado:

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

Você também pode tentar filewriter

pip install filewriter

from filewriter import Writer

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

Grava em my_file.txt

Pega um objeto iterável ou com __str__suporte.

Quando preciso escrever muitas linhas novas, defino um lambda que usa uma printfunção:

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

Essa abordagem tem o benefício de poder utilizar todos os recursos disponíveis com a printfunção.

Atualização: Como mencionado por Georgy na seção de comentários, é possível melhorar ainda mais essa idéia com a partialfunção:

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

IMHO, esta é uma abordagem mais funcional e menos enigmática.