¿Es esta la forma más limpia de escribir una lista en un archivo, ya writelines()que no inserta caracteres de nueva línea?

file.writelines(["%s\n" % item  for item in list])

Parece que habría una forma estándar ...

Puedes usar un bucle:

with open('your_file.txt', 'w') as f:
    for item in my_list:
        f.write("%s\n" % item)

En Python 2, también puedes usar

with open('your_file.txt', 'w') as f:
    for item in my_list:
        print >> f, item

Si está interesado en una sola llamada de función, al menos elimine los corchetes [], de modo que las cadenas que se imprimirán se hagan una a la vez (un genexp en lugar de un listcomp), no hay razón para ocupar toda la memoria requerida para materializar toda la lista de cadenas.

¿Qué vas a hacer con el archivo? ¿Existe este archivo para humanos u otros programas con requisitos claros de interoperabilidad?

Si solo está tratando de serializar una lista en el disco para su uso posterior por la misma aplicación de Python, debería seleccionar la lista.

import pickle

with open('outfile', 'wb') as fp:
    pickle.dump(itemlist, fp)

Para leerlo de nuevo:

with open ('outfile', 'rb') as fp:
    itemlist = pickle.load(fp)

La forma más simple es:

with open("outfile", "w") as outfile:
    outfile.write("\n".join(itemlist))

Puede asegurarse de que todos los elementos de la lista de elementos sean cadenas utilizando una expresión generadora:

with open("outfile", "w") as outfile:
    outfile.write("\n".join(str(item) for item in itemlist))

Recuerde que todas las itemlistlistas deben estar en la memoria, por lo tanto, tenga cuidado con el consumo de memoria.

Usando Python 3 y Python 2.6+ sintaxis:

with open(filepath, 'w') as file_handler:
    for item in the_list:
        file_handler.write("{}\n".format(item))

Esto es independiente de la plataforma. También termina la línea final con un carácter de nueva línea, que es una práctica recomendada para UNIX .

A partir de Python 3.6, "{}\n".format(item)se puede sustituir por un F-secuencia f"{item}\n".

Otra forma más. Serialice a json usando simplejson (incluido como json en python 2.6):

>>> import simplejson
>>> f = open('output.txt', 'w')
>>> simplejson.dump([1,2,3,4], f)
>>> f.close()

Si examina output.txt:

[1, 2, 3, 4]

Esto es útil porque la sintaxis es pitónica, es legible por humanos y otros programas la pueden leer en otros idiomas.

Pensé que sería interesante explorar los beneficios de usar un genexp, así que aquí está mi opinión.

El ejemplo en la pregunta usa corchetes para crear una lista temporal, y es equivalente a:

file.writelines( list( "%s\n" % item for item in list ) )

Lo cual construye innecesariamente una lista temporal de todas las líneas que se escribirán, esto puede consumir cantidades significativas de memoria dependiendo del tamaño de su lista y de cuán detallada es la salida de str(item).

Eliminar los corchetes (equivalente a eliminar la list()llamada de ajuste anterior) en su lugar pasará un generador temporal a file.writelines():

file.writelines( "%s\n" % item for item in list )

Este generador creará una representación terminada en línea de sus itemobjetos a pedido (es decir, a medida que se escriben). Esto es bueno por un par de razones:

• Los gastos generales de memoria son pequeños, incluso para listas muy grandes
• Si str(item)es lento, hay un progreso visible en el archivo a medida que se procesa cada elemento

Esto evita problemas de memoria, como:

In [1]: import os

In [2]: f = file(os.devnull, "w")

In [3]: %timeit f.writelines( "%s\n" % item for item in xrange(2**20) )
1 loops, best of 3: 385 ms per loop

In [4]: %timeit f.writelines( ["%s\n" % item for item in xrange(2**20)] )
ERROR: Internal Python error in the inspect module.
Below is the traceback from this internal error.

Traceback (most recent call last):
...
MemoryError

(Activé este error al limitar la memoria virtual máxima de Python a ~ 100 MB con ulimit -v 102400).

Poniendo el uso de la memoria a un lado, este método en realidad no es más rápido que el original:

In [4]: %timeit f.writelines( "%s\n" % item for item in xrange(2**20) )
1 loops, best of 3: 370 ms per loop

In [5]: %timeit f.writelines( ["%s\n" % item for item in xrange(2**20)] )
1 loops, best of 3: 360 ms per loop

(Python 2.6.2 en Linux)

Porque soy vago ...

import json
a = [1,2,3]
with open('test.txt', 'w') as f:
    f.write(json.dumps(a))

#Now read the file back into a Python list object
with open('test.txt', 'r') as f:
    a = json.loads(f.read())

Serialice la lista en un archivo de texto con un valor separado por comas

mylist = dir()
with open('filename.txt','w') as f:
    f.write( ','.join( mylist ) )

En general

La siguiente es la sintaxis para el método writelines ()

fileObject.writelines( sequence )

Ejemplo

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "rw+")
seq = ["This is 6th line\n", "This is 7th line"]

# Write sequence of lines at the end of the file.
line = fo.writelines( seq )

# Close opend file
fo.close()

Referencia

http://www.tutorialspoint.com/python/file_writelines.htm

file.write('\n'.join(list))

with open ("test.txt","w")as fp:
   for line in list12:
       fp.write(line+"\n")

También puede usar la función de impresión si está en python3 de la siguiente manera.

f = open("myfile.txt","wb")
print(mylist, file=f)

¿Por qué no lo intentas?

file.write(str(list))

Esta lógica primero convertirá los elementos de la lista a string(str). A veces la lista contiene una tupla como

alist = [(i12,tiger), 
(113,lion)]

Esta lógica escribirá para archivar cada tupla en una nueva línea. Luego podemos usar evalmientras cargamos cada tupla al leer el archivo:

outfile = open('outfile.txt', 'w') # open a file in write mode
for item in list_to_persistence:    # iterate over the list items
   outfile.write(str(item) + '\n') # write to the file
outfile.close()   # close the file 

Otra forma de iterar y agregar nueva línea:

for item in items:
    filewriter.write(f"{item}" + "\n")

En python> 3 puede usar printy *para desempaquetar argumentos:

with open("fout.txt", "w") as fout:
    print(*my_list, sep="\n", file=fout)

Deje que avg sea la lista, luego:

In [29]: a = n.array((avg))
In [31]: a.tofile('avgpoints.dat',sep='\n',dtype = '%f')

Puede usar %eo %ssegún su requerimiento.

En Python3 puedes usar este bucle

with open('your_file.txt', 'w') as f:
    for item in list:
        f.print("", item)

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
'''
f = open('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file

Cómo funciona: Primero, abra un archivo utilizando la función de apertura incorporada y especificando el nombre del archivo y el modo en el que queremos abrir el archivo. El modo puede ser un modo de lectura ('r'), un modo de escritura ('w') o un modo de adición ('a'). También podemos especificar si estamos leyendo, escribiendo o agregando en modo de texto ('t') o en modo binario ('b'). En realidad, hay muchos más modos disponibles y la ayuda (abierta) le dará más detalles sobre ellos. Por defecto, open () considera que el archivo es un 't'extfiche y lo abre en modo' r'ead. En nuestro ejemplo, primero abrimos el archivo en modo de escritura de texto y usamos el método de escritura del objeto de archivo para escribir en el archivo y luego cerramos finalmente el archivo.

El ejemplo anterior es del libro "A Byte of Python" de Swaroop C H. swaroopch.com