L'écriture d'une liste dans un fichier avec Python

Est-ce la façon la plus propre d'écrire une liste dans un fichier, depuis writelines() ne pas insérer des caractères de saut de ligne?

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

Il semble qu'il y aurait un moyen standard...

notez que writelines ne pas ajouter des retours à la ligne, car elle reflète le readlines, qui n'a pas également de les supprimer.
oui mais pourquoi ne pas readlines supprimer les retours à la ligne?
python a certainement une façon de faire ce que vous moins attendre/préférez

InformationsquelleAutor Josh Arenberg | 2009-05-22

739

Vous pouvez utiliser une boucle:
```
with open('your_file.txt', 'w') as f:
    for item in my_list:
        f.write("%s\n" % item)
```
En Python 2, vous pouvez également utiliser
```
with open('your_file.txt', 'w') as f:
    for item in my_list:
        print >> f, item
```
Si vous êtes désireux sur un simple appel de fonction, à moins de supprimer les crochets [], de sorte que les chaînes de caractères à imprimer à se faire un à la fois (un genexp plutôt qu'un listcomp) -- pas de raison de prendre toute la mémoire nécessaire pour concrétiser l'ensemble de la liste des chaînes.
- Ce n'est pas très complexe, mais pourquoi ne pas simplement utiliser le cornichon ou json, de sorte que vous n'avez pas à vous soucier de la sérialisation et de désérialisation?
- Par exemple parce que vous voulez un fichier texte de sortie qui peut être lu facilement, édité, etc, avec un élément par ligne. À peine une rare volonté;-).
- J'ai trouvé que le \n dans le premier était redondant sur Python 2.7/Windows
- Cela permettra d'écrire un supplément de caractère de saut de ligne à la fin... plutôt que de boucle, vous pouvez simplement écrire thefile.write('\n'.join(thelist))
- Je voudrais ajouter: "il faut Être prudent avec la liste type de données". J'ai été l'obtention de certains résultats bizarres, peut-être que cela peut aider quelqu'un: thefile.write(str(item) + "\n")
- Suivantes: TestFile = open("Test.txt","w+") TestFile.write("This is a test!!!!!") TestFile.close seulement me donne un fichier texte vide Test.txt Ce que je fais mal?
InformationsquelleAutor Alex Martelli
318

Qu'allez-vous faire avec le fichier? Ne ce fichier existe pour les humains, ou d'autres programmes avec claire des exigences d'interopérabilité?

Si vous essayez juste de sérialiser une liste sur le disque pour une utilisation ultérieure par le même python application, vous devez être pickleing la liste.
```
import pickle

with open('outfile', 'wb') as fp:
    pickle.dump(itemlist, fp)
```
À lire:
```
with open ('outfile', 'rb') as fp:
    itemlist = pickle.load(fp)
```
- +1 - Pourquoi réinventer la roue quand Python a la sérialisation construit dans?
- +1 - outfile est quelque chose comme: open( "save.p", "wb" ) infile est quelque chose comme: open( "save.p", "rb" )
- Le problème est que la liste doit tenir en mémoire. Si ce n'est pas le cas, ligne par ligne est en effet une stratégie possible (ou autre chose se passe avec une alternative comme dans stackoverflow.com/questions/7180212/...)
- En Python 2 utilisez 'r' au lieu de 'rb' lors de la lecture de la saumure si vous obtenez le "ValueError: l'insécurité de la chaîne de pickle"
InformationsquelleAutor SingleNegationElimination
233

La meilleure façon est:
```
outfile.write("\n".join(itemlist))
```
- Pas de suiveur de ligne, utilise l'espace 2x par rapport à la boucle.
- Bien sûr, la première question qui vient à l'esprit est de savoir si ou de ne pas l'OP en a besoin pour se terminer par un saut de ligne et de savoir si ou non le montant de l'espace matière. Vous savez ce qu'ils disent sur prématurée des optimisations.
- Un inconvénient: Il construit la totalité du contenu du fichier dans la mémoire avant d'écrire n'importe quel d'entre eux, de sorte que le pic de l'utilisation de la mémoire peut être élevée.
- Remarque à partir de la documentation du module os: Ne pas utiliser de système d'exploitation.linesep comme un terminateur de ligne lors de l'écriture des fichiers ouverts en mode texte (par défaut); utiliser un seul "\n " à la place, sur toutes les plateformes.
- Je ne peux jamais obtenir que cela fonctionne. J'obtiens cette erreur: "texte = '\n'.join(namelist) + '\n' TypeError: la séquence de l'élément 0: chaîne attendu, liste"
- Vous avez pour s'assurer que tous les éléments dans "namelist" sont des chaînes de caractères.
- Si vous voulez ajouter un point de saut de ligne ici, il suffit d'ajouter un + "\n" à la fin. Ne pas voir ce problème @Dave a avec ce.
- Pour les longue liste, cette méthode est beaucoup beaucoup plus rapide.
- Comment obtenez-vous l' outfile variable?
- Salut Jonathan, vous pouvez le faire outfile = open("output.txt", "w") # 'w' open file for writing and truncate it content ou with open("output.txt", "w") as outfile: # use outfile here.
InformationsquelleAutor osantana
86

Encore une autre façon. Sérialiser en json à l'aide de simplejson (inclus en tant que json en python 2.6):
```
>>> import simplejson
>>> f = open('output.txt', 'w')
>>> simplejson.dump([1,2,3,4], f)
>>> f.close()
```
Si vous examinez output.txt:

[1, 2, 3, 4]

C'est utile parce que la syntaxe est pythonic, il est lisible par l'homme, et il peut être lu par d'autres programmes dans d'autres langues.
- simplejson.charge(f) de lire ce qui a été écrit.
- fonctionne aussi bien pour les listes imbriquées 🙂
InformationsquelleAutor Jason Baker
85

À l'aide de Python 3 et Python 2.6+ syntaxe:
```
with open(filepath, 'w') as file_handler:
    for item in the_list:
        file_handler.write("{}\n".format(item))
```
C'est indépendant de la plateforme. Il met aussi fin à la dernière ligne avec un caractère de saut de ligne, ce qui est un UNIX meilleures pratiques.
- je ne veux pas ajouter "\n" pour le dernier élément, que faire? ne voulons pas que si la condition
- Remplacer la boucle for avec file_handler.write("\n".join(str(item) for item in the_list))
InformationsquelleAutor orluke
36

J'ai pensé qu'il serait intéressant d'explorer les avantages de l'utilisation d'un genexp, voici donc mon point de vue.

L'exemple en question utilise des crochets pour créer une liste temporaire, et est donc équivalent à:
```
file.writelines( list( "%s\n" % item for item in list ) )
```
Qui inutilement constructions temporaires liste de toutes les lignes qui sera écrit, cela peut consommer d'importantes quantités de mémoire selon la taille de votre liste et la façon dont détaillé de la sortie de str(item) est.

Déposer les crochets (l'équivalent du retrait de l'emballage list() appel ci-dessus) au lieu de passer temporaire générateur à file.writelines():
```
file.writelines( "%s\n" % item for item in list )
```
Ce générateur va créer un saut de ligne-mis fin à la représentation de votre item des objets à la demande (c'est à dire qu'ils sont écrites). C'est bien pour un couple de raisons:
- Mémoire de frais généraux sont de petite taille, même pour de très grandes listes
- Si str(item) est lent, il y a des progrès visibles dans le fichier que chaque élément est traité
Cela évite les problèmes de mémoire, tels que:
```
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
```
(J'ai déclenché cette erreur en limitant Python max. la mémoire virtuelle à ~100 MO avec ulimit -v 102400).

Mettre de l'utilisation de la mémoire d'un côté, cette méthode n'est en fait pas plus vite que l'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 sur Linux)
- +1 - vraiment la meilleure approche dans le cas de fichiers volumineux.
InformationsquelleAutor RobM
19

Sérialiser liste dans un fichier texte avec virgule sepparated valeur
```
mylist = dir()
with open('filename.txt','w') as f:
    f.write( ','.join( mylist ) )
```
InformationsquelleAutor themadmax
18

Parce que je suis paresseux....
```
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())
```
- sont des listes json sérialisable?
- Oui en effet, ils sont!
- importation json ; test_list = [1,2,3]; list_as_a_string = json.décharges(test_list); #list_as_a_string est maintenant la chaîne de caractères " [1,2,3]'
- Je suis en train de faire ce with open ('Sp1.txt', 'a') as outfile: json.dump (sp1_segments, outfile) logger.info ("Saved sp_1 segments") ; le problème est que mon programme s'exécute trois fois, et les résultats de trois essais se sont réduits en purée. est-il possible d'ajouter 1-2 lignes vides ainsi que les résultats de chaque course sont perceptibles?
- Absolument! pourriez-vous faire au lieu de json.dump(sp1_segments + "\n\n", outfile)?
InformationsquelleAutor CommandoScorch

En Général

La syntaxe est la suivante pour writelines() méthode

fileObject.writelines( sequence )

Exemple

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

Référence

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

InformationsquelleAutor Marvin W

12
```
file.write('\n'.join(list))
```
- Il convient de noter qu'il faudrait que le fichier doit être ouvert en tant que texte pour être vraiment plate-forme neutre.
- Comment obtenez-vous l' file variable?
InformationsquelleAutor mtasic85

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

InformationsquelleAutor shankar

7

Vous pouvez également utiliser la fonction d'impression si vous êtes sur python3 comme suit.
```
f = open("myfile.txt","wb")
print(mylist, file=f)
```
- n'est-il pas seulement de mettre une ligne dans myfile.txt, quelque chose comme: ['a','b','c'] au lieu d'écrire chacun a,b,c sur chaque ligne.
InformationsquelleAutor Nandita Damaraju
3

Pourquoi n'essayez-vous pas
```
file.write(str(list))
```
InformationsquelleAutor Bob
2

Cette logique va d'abord convertir les éléments en string(str). Parfois, la liste contient un tuple comme
```
alist = [(i12,tiger), 
(113,lion)]
```
Cette logique d'écriture de fichier de chaque tuple dans une nouvelle ligne. Plus tard, nous pouvons utiliser eval lors du chargement de chaque tuple lors de la lecture du fichier:
```
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 
```
InformationsquelleAutor Tahir Ahmad
1

Une autre façon de retravailler et d'ajouter un saut de ligne:
```
for item in items:
    filewriter.write(f"{item}" + "\n")
```
InformationsquelleAutor Alex
-2

Laissez-moy la liste, puis:
```
In [29]: a = n.array((avg))
In [31]: a.tofile('avgpoints.dat',sep='\n',dtype = '%f')
```
Vous pouvez utiliser %e ou %s en fonction de vos besoins.

InformationsquelleAutor belthazar
-2
```
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
```
Comment Il Fonctionne:
Tout d'abord, ouvrez un fichier en utilisant le construit en fonction d'ouverture et en spécifiant le nom de
le fichier et le mode dans lequel nous voulons ouvrir le fichier. La mode peut être un
mode de lecture ("r"), le mode write (’w’) ou en mode append (’a’). On peut aussi spécifier l'
si nous sommes à la lecture, l'écriture, ou en ajoutant en mode texte ("t") ou binaire
mode (’b’). Il y a effectivement beaucoup plus de modes disponibles et de l'aide(ouvert)
vous donnera plus de détails à leur sujet. Par défaut, open() considère que le fichier à
être un "t'ext fichier et l'ouvre en" r'ead mode.
Dans notre exemple, nous avons d'abord ouvrir le fichier en écriture en mode texte et utiliser l'écriture
méthode de l'objet fichier à écrire dans le fichier et puis nous avons enfin fermer le fichier.

L'exemple ci-dessus est tirée du livre "Un Octet de Python" par Swaroop C H.
swaroopch.com
- Ceci écrit une chaîne de caractères dans un fichier, pas une liste de chaînes de caractères) que l'OP demande
InformationsquelleAutor vayah

Vous devez vous connecter pour publier un commentaire.