È questo il modo più pulito per scrivere un elenco in un file, dal momento writelines()che non inserisce caratteri di nuova riga?

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

Sembra che ci sarebbe un modo standard ...

Puoi usare un loop:

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

In Python 2, puoi anche usare

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

Se sei appassionato di una singola chiamata di funzione, almeno rimuovi le parentesi quadre [], in modo che le stringhe da stampare vengano create una alla volta (un genexp anziché un listcomp) - nessun motivo per occupare tutta la memoria richiesta per materializzare l'intero elenco di stringhe.

Che cosa hai intenzione di fare con il file? Questo file esiste per gli esseri umani o altri programmi con chiari requisiti di interoperabilità?

Se stai solo cercando di serializzare un elenco su disco per un uso successivo da parte della stessa app Python, dovresti cercare l'elenco.

import pickle

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

Per rileggerlo:

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

Il modo più semplice è:

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

È possibile assicurarsi che tutti gli elementi nell'elenco degli elementi siano stringhe utilizzando un'espressione del generatore:

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

Ricorda che tutti gli itemlistelenchi devono essere in memoria, quindi fai attenzione al consumo di memoria.

Uso della sintassi di Python 3 e Python 2.6+ :

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

Questo è indipendente dalla piattaforma. Termina anche la riga finale con un carattere di nuova riga, che è una best practice UNIX .

A partire da Python 3.6, "{}\n".format(item)può essere sostituito con un F-stringa: f"{item}\n".

Ancora un altro modo. Serializza su json usando simplejson (incluso come json in python 2.6):

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

Se si esamina output.txt:

[1, 2, 3, 4]

Ciò è utile perché la sintassi è pitonica, è leggibile dall'uomo e può essere letta da altri programmi in altre lingue.

Ho pensato che sarebbe interessante esplorare i vantaggi dell'utilizzo di un genexp, quindi ecco la mia opinione.

L'esempio nella domanda usa parentesi quadre per creare un elenco temporaneo, quindi equivale a:

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

Che costruisce inutilmente un elenco temporaneo di tutte le righe che verranno scritte, ciò può consumare quantità significative di memoria a seconda delle dimensioni dell'elenco e di quanto sia dettagliato l'output di str(item).

Rilasciare le parentesi quadre (equivalenti a rimuovere la list()chiamata di wrapping sopra) passerà invece un generatore temporaneo a file.writelines():

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

Questo generatore creerà una rappresentazione con terminazione di nuova riga dei tuoi itemoggetti su richiesta (cioè quando vengono scritti). Questo è carino per un paio di motivi:

• I costi di memoria sono piccoli, anche per elenchi molto grandi
• Se str(item)è lento ci sono progressi visibili nel file mentre ogni elemento viene elaborato

Questo evita problemi di memoria, come:

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

(Ho attivato questo errore limitando la memoria virtuale massima di Python a ~ 100 MB con ulimit -v 102400).

Mettendo da parte l'utilizzo della memoria, questo metodo non è in realtà più veloce dell'originale:

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 su Linux)

Perché sono pigro ...

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())

Serializza l'elenco in un file di testo con un valore separato da virgola

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

In generale

Ciò che segue è la sintassi per writelines () metodo

fileObject.writelines( sequence )

Esempio

#!/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()

Riferimento

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")

Puoi anche usare la funzione di stampa se sei su python3 come segue.

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

Perché non ci provi

file.write(str(list))

Questa logica convertirà innanzitutto gli elementi nell'elenco string(str). A volte l'elenco contiene una tupla come

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

Questa logica scriverà per archiviare ogni tupla in una nuova riga. In seguito possiamo usare evaldurante il caricamento di ogni tupla durante la lettura del file:

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 

Un altro modo di iterare e aggiungere newline:

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

In python> 3 puoi usare printe *per spacchettare argomenti:

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

Lascia che avg sia l'elenco, quindi:

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

È possibile utilizzare %eo in %sbase alle proprie esigenze.

In Python3 puoi usare questo loop

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

Come funziona: Innanzitutto, apri un file utilizzando la funzione di apertura integrata e specificando il nome del file e la modalità in cui vogliamo aprire il file. La modalità può essere una modalità di lettura ('r'), una modalità di scrittura ('w') o una modalità di aggiunta ('a'). Possiamo anche specificare se stiamo leggendo, scrivendo o aggiungendo in modalità testo ('t') o binaria ('b'). In realtà ci sono molte altre modalità disponibili e aiuto (aperto) ti darà maggiori dettagli su di esse. Per impostazione predefinita, open () considera il file come file 't'ext e lo apre in modalità' r'ead. Nel nostro esempio, apriamo prima il file in modalità di scrittura del testo e utilizziamo il metodo write dell'oggetto file per scrivere sul file, quindi chiudiamo il file.

L'esempio sopra è tratto dal libro "A Byte of Python" di Swaroop C H. swaroopch.com