Een lijst naar een bestand schrijven met Python

Is dit de schoonste manier om een ​​lijst naar een bestand te schrijven, aangezien writelines()geen nieuwe regeltekens invoegt?

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

Het lijkt erop dat er een standaard manier zou zijn…

Antwoord 1, autoriteit 100%

U kunt een lus gebruiken:

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

In Python 2 kun je ook

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

Als je geïnteresseerd bent in een enkele functie-aanroep, verwijder dan op zijn minst de vierkante haken [], zodat de te printen strings één voor één gemaakt worden (een genexp in plaats van een listcomp ) — geen reden om al het geheugen in beslag te nemen dat nodig is om de hele lijst met strings te maken.

Antwoord 2, autoriteit 40%

Wat gaat u met het bestand doen? Bestaat dit bestand voor mensen of andere programma’s met duidelijke interoperabiliteitsvereisten?

Als je alleen een lijst probeert te serialiseren naar schijf voor later gebruik door dezelfde python-app, moet je beitsende lijst.

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

Om het terug te lezen:

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

Antwoord 3, autoriteit 32%

De eenvoudigere manier is:

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

U kunt ervoor zorgen dat alle items in de itemlijst strings zijn met behulp van een generator-expressie:

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

Vergeet niet dat alle itemlist-lijsten in het geheugen moeten staan, dus let op het geheugengebruik.

Antwoord 4, autoriteit 9%

Gebruik Python 3en Python 2.6+syntaxis:

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

Dit is platformonafhankelijk. Het beëindigt ook de laatste regel met een teken voor een nieuwe regel, wat een UNIX-beste oefenen.

Vanaf Python 3.6 kan "{}\n".format(item)worden vervangen door een f-string: f"{item}\n".

Antwoord 5, autoriteit 8%

Nog een andere manier. Serialiseren naar json met behulp van simplejson(opgenomen als jsonin python 2.6):

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

Als je output.txt onderzoekt:

[1, 2, 3, 4]

Dit is handig omdat de syntaxis pythonisch is, door mensen leesbaar en door andere programma’s in andere talen kan worden gelezen.

Antwoord 6, autoriteit 4%

Ik dacht dat het interessant zou zijn om de voordelen van het gebruik van een genexp te onderzoeken, dus hier is mijn mening.

Het voorbeeld in de vraag gebruikt vierkante haken om een ​​tijdelijke lijst te maken, en is dus gelijk aan:

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

Dat nodeloos een tijdelijke lijst maakt van alle regels die zullen worden weggeschreven, dit kan aanzienlijke hoeveelheden geheugen verbruiken, afhankelijk van de grootte van uw lijst en hoe uitgebreid de uitvoer van str(item)is.

Laat de vierkante haken vallen (gelijk aan het verwijderen van de omhullende list()-aanroep hierboven) zal in plaats daarvan een tijdelijke generatornaar file.writelines():

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

Deze generator zal on-demand (d.w.z. zoals ze worden uitgeschreven) een weergave van uw item-objecten maken met een nieuwe regel. Dit is leuk om een ​​aantal redenen:

• De overheadkosten voor het geheugen zijn klein, zelfs voor zeer grote lijsten
• Als str(item)traag is, is er zichtbare voortgang in het bestand terwijl elk item wordt verwerkt

Dit voorkomt geheugenproblemen, zoals:

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

(Ik heb deze fout geactiveerd door het maximale virtuele geheugen van Python te beperken tot ~100 MB met ulimit -v 102400).

Als we het geheugengebruik aan de kant schuiven, deze methode is eigenlijk niet sneller dan het origineel:

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

Antwoord 7, autoriteit 2%

Omdat ik lui ben….

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

Antwoord 8, autoriteit 2%

Serialiseer lijst in tekstbestand met door komma’s gescheiden waarde

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

Antwoord 9

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

Antwoord 10

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

Antwoord 11

Je kunt de afdrukfunctie ook als volgt gebruiken als je op python3 werkt.

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

Antwoord 12

In python>3 kun je printen *gebruiken voor het uitpakken van argumenten:

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

Antwoord 13

Waarom probeer je het niet

file.write(str(list))

Antwoord 14

Het gebruik van numpy.savetxtis ook een optie:

import numpy as np
np.savetxt('list.txt', list, delimiter="\n", fmt="%s")

Antwoord 15

Deze logica zal eerst de items in de lijst converteren naar string(str). Soms bevat de lijst een tuple zoals

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

Deze logica schrijft naar elke tuple in een nieuwe regel. We kunnen later evalgebruiken tijdens het laden van elke tuple bij het lezen van het bestand:

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 

Antwoord 16

Je kunt ook het volgende doen:

Voorbeeld:

my_list=[1,2,3,4,5,"abc","def"]
with open('your_file.txt', 'w') as file:
    for item in my_list:
        file.write("%s\n" % item)

Uitvoer:

In your_file.txtworden items opgeslagen zoals:

1
2
3
4
5
abc
def

Je script wordt ook opgeslagen zoals hierboven.

Anders kun je augurk gebruiken

import pickle
my_list=[1,2,3,4,5,"abc","def"]
#to write
with open('your_file.txt', 'wb') as file:
    pickle.dump(my_list, file)
#to read
with open ('your_file.txt', 'rb') as file:
    Outlist = pickle.load(file)
print(Outlist)

Uitvoer:
[1, 2, 3, 4, 5, ‘abc’, ‘def’]

Het slaat de lijst op dezelfde manier op als een lijst, wanneer we deze laden, kunnen we deze lezen.

Ook door simplejsonmogelijk hetzelfde als bovenstaande uitvoer

import simplejson as sj
my_list=[1,2,3,4,5,"abc","def"]
#To write
with open('your_file.txt', 'w') as file:
    sj.dump(my_list, file)
#To save
with open('your_file.txt', 'r') as file:
    mlist=sj.load(file)
print(mlist)

Antwoord 17

Een andere manier om te herhalen en een nieuwe regel toe te voegen:

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

Antwoord 18

Het omleiden van stdout naar een bestand kan ook nuttig zijn voor dit doel:

from contextlib import redirect_stdout
with open('test.txt', 'w') as f:
  with redirect_stdout(f):
     for i in range(mylst.size):
        print(mylst[i])

Antwoord 19

ik stel deze oplossing voor.

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

Antwoord 20

In Python3kun je deze lus gebruiken

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

Antwoord 21

Geef avg de lijst en dan:

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

U kunt %eof %sgebruiken, afhankelijk van uw behoefte.

Antwoord 22

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

Hoe het werkt:
Open eerst een bestand met behulp van de ingebouwde open-functie en specificeer de naam van
het bestand en de modus waarin we het bestand willen openen. De modus kan een
leesmodus ( r ), schrijfmodus ( w ) of toevoegmodus ( a ). We kunnen ook specificeren:
of we nu lezen, schrijven of toevoegen in tekstmodus ( t ) of binair
modus ( b ). Er zijn eigenlijk nog veel meer modi beschikbaar en help(open)
zal u meer details over hen geven. Standaard beschouwt open() het ?le to
be a t ext ?le en opent het in de r ead-modus.
In ons voorbeeld openen we eerst het bestand in de modus tekst schrijven en gebruiken we het bestand schrijven
methode van het ?le-object om naar het ?le te schrijven en dan sluiten we uiteindelijk het ?le.

Het bovenstaande voorbeeld komt uit het boek “A Byte of Python” van Swaroop C H.
swaroopch.com