convertir liste de listes dans une chaîne

J'ai une liste, dans laquelle est une autre liste et je veux doc.write(a)

a = [[1, 2, "hello"],
     [3, 5, "hi There"],
     [5,7,"I don't know"]]
doc.write(''.join(a))



TypeError: sequence item 0: expected str instance, list found

Comment puis-je gérer cela, je dois faire une boucle for dans laquelle je m'associe et ajoutez tous les sous-listes?

Le véritable but était de faire d'une certaine manière lisible pour l'homme être, mais je n'ai pas voulu faire un produit fini de la solution auprès de vous.

Que voulez-vous faire avec les nombres?
S'il vous plaît montrer la sortie réelle que vous voulez.
Je veux écrire la liste dans un fichier texte. D'une certaine manière.
Et vous ne se soucient pas comment? Il n'a pas besoin d'être re-parseable par votre code, ou lisible par un être humain, ou importables dans un autre programme, ou quoi que ce soit? Dans ce cas, il suffit de faire write('stuff') et vous avez terminé.
Ce qui est "autre chose"??

OriginalL'auteur inetphantom | 2013-10-31

13

Vous pouvez essayer quelque chose comme
```
>>> a = [[1, 2, "hello"],[3, 5, "hi There"],[5,7,"I don't know"]]
>>> 
>>> ''.join(str(r) for v in a for r in v)
"12hello35hi There57I don't know"
```
c'est à dire
```
doc.write(''.join(str(r) for v in a for r in v))
```
Cela a été un long temps depuis que la réponse grâce à '\t'.join() cela peut être embellie d'un onglet liste séparée qui peut être plus lisible.

OriginalL'auteur arshajii
3

Il y a différentes choses que vous pouvez faire, et aucun moyen pour quiconque de dire laquelle est la bonne, sans savoir à qui vous voulez.

Première, vous pouvez tout simplement écrire le str ou repr de a:
```
>>> a=[[1, 2, "hello"],[3, 5, "hi There"],[5,7,"I don't know"]]
>>> repr(a)
'[[1, 2, \'hello\'], [3, 5, \'hi There\'], [5, 7, "I don\'t know"]]'
```
Noter que c'est ce que print n' (il imprime le str de ce que vous donnez à elle—même si une liste, la str est identique à la repr; ils sont à la fois efficacement '[' + ', '.join(map(repr, self)) + ']').

Seconde, vous pouvez utiliser un format conçu pour les données persistantes, comme JSON:
```
>>> json.dumps(a)
'[[1, 2, "hello"], [3, 5, "hi There"], [5, 7, "I don\'t know"]]'
```
Troisième, vous pouvez joindre les repr de chaque élément de a en quelque sorte de votre choix, ce qui est trivial avec une map ou de compréhension. Par exemple:
```
>>> '[' + ', '.join(map(repr, a)) + ']'
'[[1, 2, \'hello\'], [3, 5, \'hi There\'], [5, 7, "I don\'t know"]]'
```
... ...
```
>>> 'My stuff includes: ' + ','.join(map(repr, a)) + '\n'
'My stuff includes: [1, 2, \'hello\'],[3, 5, \'hi There\'],[5, 7, "I don\'t know"]\n'
```
Ou vous pouvez faire la même chose de manière récursive.

Ou vous pouvez les aplatir la liste (par exemple, l'aplatir en une seule étape avec itertools.chain, ou de manière récursive avec les recettes de la itertools docs ou avec la more-itertools colis) stringify les pièces comme vous le souhaitez et ensuite se joindre à eux.

Ou vous pouvez tout simplement écrire le mot LIST.

Tous ceux qui sont parfaitement valables choses à transmettre à write.

OriginalL'auteur abarnert
3

Compréhension de liste serait le meilleur choix:
```
>>> ''.join([str(item) for sublist in a for item in sublist])
"12hello35hi There57I don't know"
```
Il est le plus à l'approche recommandée dans un semblable question, compte tenu de la performance et de la syntaxe.

OriginalL'auteur jlr
0

Que sur l'utilisation de itertools?
```
from itertools import chain
doc.write(''.join(map(str, chain(a))))
```
Sinon:
```
doc.write(''.join(str(i) for sub_list in a for i in sub_list))
```
Vous proposé une aide d'un for boucle. En effet, vous pourriez le faire, bien que les options ci-dessus sont probablement mieux.
```
new_a = []
for sub_list in a:
    for i in sublist:
        new_a.append(str(i))
doc.write(''.join(new_a))
```
C'est en gros l'option précédente, mais déroulé.

Sauf si vous voulez juste écrire le premier de la liste, dans ce cas, vous pourriez faire ceci:
```
doc.write(''.join(map(str, a[0])))
```
OriginalL'auteur rlms
0

Il est difficile pour moi de m'assurer, parce que votre question est trop court, mais il me semble que vous êtes dans un XY problème, c'est-à-dire :

vous posez une question à propos de un Y un problème que vous pensez comme étant celui qui doit être résolu au sort de la montée X problème. Mais votre vrai problème, c'est que vous pensez que Y problème est la façon de répondre au problème réel X ET que vous ne présentons ici que la Y problème de.

Pour l'écrire, je ne paraphraser ce qui est dit ici: XY problème

Si je suis en droit, mon opinion est que vous aurez une meilleure façon de résoudre votre X réel problème en utilisant l'un des outils suivants, qui permet de sérialiser un objet et à l'enregistrement de l'objet sérialisé dans un fichier:

cornichon

maréchal

étagère

Je ne vais pas paraphraser et de répéter tous les est les docs sur ces outils, de les lire.

.

Si je me trompe et que vous voulez juste écrire un objet sous la forme d'une représentation de chaîne, vous pouvez également le faire:
```
from pprint import pformat

a = [[1, 2, "hello"],
     [3, 5, "hi There"],
     [5,7,"I don't know"]]

with open('doc.txt','w') as f:
    f.write(pformat(a,width=12))
```
C'est plus un commentaire qu'une réponse.
Je ne pense pas que ce soit utile. L'OP n'est pas de demander à propos de la façon de faire quelque chose à tort (par exemple, analyser XML avec la regex), mais une question raisonnable. Les modules que vous avez donné ne sont pas très utiles en termes d'écriture lisible par l'utilisateur "textefichier" (mon emphase), et je crois que le lien seules réponses sont découragés.
J'ai habituellement apprécier vos réponses et commentaires, mais, actuellement, je ne comprends pas ce commentaire de la vôtre. Il me semble que le point crucial est: suis-je droit quand on pense que l'OP essaie de trouver un moyen pour appliquer une mauvaise solution à son problème au lieu de trouver un vrai bon et adapté soulution. Si oui, mon avis, que les réponses à ses X problème, au lieu de répondre à l'O de la pseudo-solution, mérite autant d'un format de réponse que les autres réponses, à mon avis.
Où voyez-vous des allusions à de XML et de regex dans la question et dans ma réponse ?????
Expliquer pourquoi la question n'est pas une bonne question n'est pas une réponse. Toute réponse qui correspond plus ou moins à celui de la proximité des raisons n'est pas une réponse. Même si c'était le cas, une liste de liens avec aucun commentaire n'est pas une réponse. Donc, ce n'est pas une réponse. (Cela dit, celui qui downvoted votre réponse doit probablement avoir signalé que "Pas de Réponse" au lieu de cela, comme il est expliqué ici.)

OriginalL'auteur eyquem
0

Vous pouvez aussi utiliser un simple compréhension de liste comme ceci:
```
doc.write([x for x in i for i in a])
```
OriginalL'auteur PythonNoob

Vous devez vous connecter pour publier un commentaire.