Comment imprimer une liste en Python «bien»

En PHP, je peux faire ceci:

echo '<pre>'
print_r($array);
echo '</pre>'

En Python, je fais actuellement ceci:

print the_list

Cependant, cela entraînera un gros jumbo de données. Existe-t-il un moyen de l'imprimer correctement dans un arbre lisible? (avec des retraits)?

from pprint import pprint
pprint(the_list)

Un hack rapide lors du débogage qui fonctionne sans avoir à importer pprintserait de rejoindre la liste '\n'.

>>> lst = ['foo', 'bar', 'spam', 'egg']
>>> print '\n'.join(lst)
foo
bar
spam
egg

Simplement en "décompressant" la liste dans l'argument de la fonction d'impression et en utilisant une nouvelle ligne (\ n) comme séparateur.

impression (* lst, sep = '\ n')

lst = ['foo', 'bar', 'spam', 'egg']
print(*lst, sep='\n')

foo
bar
spam
egg

Vous voulez dire quelque chose comme ...:

>>> print L
['this', 'is', 'a', ['and', 'a', 'sublist', 'too'], 'list', 'including', 'many', 'words', 'in', 'it']
>>> import pprint
>>> pprint.pprint(L)
['this',
 'is',
 'a',
 ['and', 'a', 'sublist', 'too'],
 'list',
 'including',
 'many',
 'words',
 'in',
 'it']
>>> 

...? D'après votre description superficielle, le module de bibliothèque standard pprint est la première chose qui vous vient à l'esprit; cependant, si vous pouvez décrire des exemples d'entrées et de sorties (pour ne pas avoir à apprendre PHP pour vous aider ;-), il nous sera peut-être possible de vous proposer une aide plus spécifique!

import json
some_list = ['one', 'two', 'three', 'four']
print(json.dumps(some_list, indent=4))

Production:

[
    "one",
    "two",
    "three",
    "four"
]

https://docs.python.org/3/library/pprint.html

Si vous avez besoin du texte (pour une utilisation avec des malédictions par exemple):

import pprint

myObject = []

myText = pprint.pformat(myObject)

Ensuite, la myTextvariable sera quelque chose de semblable à php var_dumpou print_r. Consultez la documentation pour plus d'options, d'arguments.

Comme les autres réponses le suggèrent, le module pprint fait l'affaire.
Néanmoins, en cas de débogage où vous pourriez avoir besoin de mettre la liste entière dans un fichier journal, vous devrez peut-être utiliser la méthode pformat avec la journalisation du module avec pprint.

import logging
from pprint import pformat

logger = logging.getLogger('newlogger')
handler = logging.FileHandler('newlogger.log')

formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handler.setFormatter(formatter)

logger.addHandler(handler) 
logger.setLevel(logging.WARNING)

data = [ (i, { '1':'one',
           '2':'two',
           '3':'three',
           '4':'four',
           '5':'five',
           '6':'six',
           '7':'seven',
           '8':'eight',
           })
         for i in xrange(3)
      ]

logger.error(pformat(data))

Et si vous avez besoin de le connecter directement à un fichier, il faudrait spécifier un flux de sortie, en utilisant le mot-clé stream. Réf

from pprint import pprint

with open('output.txt', 'wt') as out:
   pprint(myTree, stream=out)

Voir la réponse de Stefano Sanfilippo

Pour Python 3 , je fais le même genre de chose que la réponse de shxfee :

def print_list(my_list):
    print('\n'.join(my_list))

a = ['foo', 'bar', 'baz']
print_list(a)

quelles sorties

foo
bar
baz

En passant, j'utilise une fonction d'assistance similaire pour voir rapidement les colonnes dans un pandas DataFrame

def print_cols(df):
    print('\n'.join(df.columns))

Comme d'autres réponses l'ont mentionné, pprintc'est un excellent module qui fera ce que vous voulez. Cependant, si vous ne voulez pas l'importer et que vous voulez simplement imprimer la sortie de débogage pendant le développement, vous pouvez approximer sa sortie.

Certaines des autres réponses fonctionnent bien pour les chaînes, mais si vous les essayez avec un objet de classe, cela vous donnera l'erreur TypeError: sequence item 0: expected string, instance found.

Pour les objets plus complexes, assurez-vous que la classe dispose d'une __repr__méthode qui imprime les informations de propriété souhaitées:

class Foo(object):
    def __init__(self, bar):
        self.bar = bar

    def __repr__(self):
        return "Foo - (%r)" % self.bar

Et puis, lorsque vous souhaitez imprimer la sortie, mappez simplement votre liste à la strfonction comme ceci:

l = [Foo(10), Foo(20), Foo("A string"), Foo(2.4)]
print "[%s]" % ",\n ".join(map(str,l))

les sorties:

 [Foo - (10),
  Foo - (20),
  Foo - ('A string'),
  Foo - (2.4)]

Vous pouvez également faire des choses comme remplacer la __repr__méthode de listpour obtenir une forme d'impression jolie imbriquée:

class my_list(list):
    def __repr__(self):
        return "[%s]" % ",\n ".join(map(str, self))

a = my_list(["first", 2, my_list(["another", "list", "here"]), "last"])
print a

donne

[first,
 2,
 [another,
 list,
 here],
 last]

Malheureusement pas d'indentation de deuxième niveau mais pour un débogage rapide cela peut être utile.

vous pouvez également parcourir votre liste en boucle:

def fun():
  for i in x:
    print(i)

x = ["1",1,"a",8]
fun()