Ist dies der sauberste Weg, eine Liste in eine Datei zu schreiben, da writelines()keine Zeilenumbrüche eingefügt werden?

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

Es scheint, als gäbe es einen Standardweg ...

Sie können eine Schleife verwenden:

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

In Python 2 können Sie auch verwenden

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

Wenn Sie an einem einzelnen Funktionsaufruf interessiert sind, entfernen Sie mindestens die eckigen Klammern [], damit die zu druckenden Zeichenfolgen einzeln erstellt werden (ein Genexp anstelle eines Listcomp) - kein Grund, den gesamten erforderlichen Speicher zu belegen die gesamte Liste der Zeichenfolgen zu materialisieren.

Was machst du mit der Datei? Existiert diese Datei für Menschen oder andere Programme mit klaren Interoperabilitätsanforderungen?

Wenn Sie nur versuchen, eine Liste zur späteren Verwendung durch dieselbe Python-App auf die Festplatte zu serialisieren, sollten Sie die Liste auswählen .

import pickle

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

Um es zurückzulesen:

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

Der einfachere Weg ist:

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

Sie können mithilfe eines Generatorausdrucks sicherstellen, dass alle Elemente in der Elementliste Zeichenfolgen sind:

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

Denken Sie daran, dass sich alle itemlistListen im Speicher befinden müssen. Achten Sie daher auf den Speicherverbrauch.

Verwenden der Syntax von Python 3 und Python 2.6+ :

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

Dies ist plattformunabhängig. Außerdem wird die letzte Zeile mit einem Zeilenumbruchzeichen abgeschlossen. Dies ist eine bewährte Methode für UNIX .

Ab Python 3.6 "{}\n".format(item)kann durch einen F-String ersetzt werden : f"{item}\n".

Noch ein anderer Weg. Serialisieren Sie mit simplejson zu json ( in Python 2.6 als json enthalten ):

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

Wenn Sie output.txt untersuchen:

[1, 2, 3, 4]

Dies ist nützlich, da die Syntax pythonisch ist, von Menschen gelesen werden kann und von anderen Programmen in anderen Sprachen gelesen werden kann.

Ich dachte, es wäre interessant, die Vorteile der Verwendung eines Genexp zu untersuchen. Hier ist meine Meinung.

Das Beispiel in der Frage verwendet eckige Klammern, um eine temporäre Liste zu erstellen. Dies entspricht:

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

Dadurch wird unnötig eine temporäre Liste aller Zeilen erstellt, die ausgeschrieben werden. Dies kann je nach Größe Ihrer Liste und der Ausführlichkeit der Ausgabe erhebliche Speichermengen beanspruchen str(item).

Wenn Sie die eckigen Klammern entfernen (entspricht dem Entfernen des list()obigen Wrapping- Aufrufs), wird stattdessen ein temporärer Generator an Folgendes übergebenfile.writelines() :

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

Dieser Generator erstellt bei Bedarf eine Newline-terminierte Darstellung Ihrer itemObjekte (dh wie sie ausgeschrieben sind). Das ist aus mehreren Gründen schön:

• Der Speicheraufwand ist selbst bei sehr großen Listen gering
• Wenn str(item)es langsam ist, gibt es sichtbaren Fortschritt in der Datei, während jedes Element verarbeitet wird

Dies vermeidet Speicherprobleme wie:

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

(Ich habe diesen Fehler ausgelöst, indem ich Pythons maximalen virtuellen Speicher auf ~ 100 MB mit begrenzt habe ulimit -v 102400).

Wenn Sie die Speichernutzung beiseite lassen, ist diese Methode nicht schneller als das 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 unter Linux)

Weil ich faul bin....

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

Serialisieren Sie die Liste in eine Textdatei mit einem durch Kommas getrennten Wert

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

Allgemein

Es folgt die Syntax für die Methode writelines ()

fileObject.writelines( sequence )

Beispiel

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

Referenz

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

Sie können die Druckfunktion auch wie folgt verwenden, wenn Sie sich in Python3 befinden.

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

Warum versuchst du es nicht?

file.write(str(list))

Diese Logik konvertiert zuerst die Elemente in der Liste in string(str). Manchmal enthält die Liste ein Tupel wie

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

Diese Logik schreibt, um jedes Tupel in einer neuen Zeile abzulegen. Wir können später evalbeim Laden jedes Tupels beim Lesen der Datei Folgendes verwenden:

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 

Eine andere Möglichkeit zum Iterieren und Hinzufügen von Zeilenumbrüchen:

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

In Python> 3 können Sie printund *zum Entpacken von Argumenten verwenden:

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

In Python3 können Sie diese Schleife verwenden

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

Sei avg die Liste, dann:

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

Sie können %eoder %sje nach Ihren Anforderungen verwenden.

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

So funktioniert es: Öffnen Sie zunächst eine Datei, indem Sie die integrierte Öffnungsfunktion verwenden und den Namen der Datei sowie den Modus angeben, in dem die Datei geöffnet werden soll. Der Modus kann ein Lesemodus ('r'), ein Schreibmodus ('w') oder ein Anhänge-Modus ('a') sein. Wir können auch angeben, ob wir im Textmodus ('t') oder im Binärmodus ('b') lesen, schreiben oder anhängen. Es gibt tatsächlich viel mehr Modi und die Hilfe (offen) gibt Ihnen mehr Details darüber. Standardmäßig betrachtet open () die Datei als 't'ext-Datei' und öffnet sie im 'r'ead-Modus. In unserem Beispiel öffnen wir zuerst die Datei im Schreibtextmodus und verwenden die Schreibmethode des Dateiobjekts, um in die Datei zu schreiben. Anschließend schließen wir die Datei endgültig.

Das obige Beispiel stammt aus dem Buch "A Byte of Python" von Swaroop C H. swaroopch.com