D'après ce qui a été fait, je ne vois aucune jolie imprimante qui imite au moins la sortie de l'interpréteur python avec un formatage très simple alors voici le mien:
class Formatter(object):
def __init__(self):
self.types = {}
self.htchar = '\t'
self.lfchar = '\n'
self.indent = 0
self.set_formater(object, self.__class__.format_object)
self.set_formater(dict, self.__class__.format_dict)
self.set_formater(list, self.__class__.format_list)
self.set_formater(tuple, self.__class__.format_tuple)
def set_formater(self, obj, callback):
self.types[obj] = callback
def __call__(self, value, **args):
for key in args:
setattr(self, key, args[key])
formater = self.types[type(value) if type(value) in self.types else object]
return formater(self, value, self.indent)
def format_object(self, value, indent):
return repr(value)
def format_dict(self, value, indent):
items = [
self.lfchar + self.htchar * (indent + 1) + repr(key) + ': ' +
(self.types[type(value[key]) if type(value[key]) in self.types else object])(self, value[key], indent + 1)
for key in value
]
return '{%s}' % (','.join(items) + self.lfchar + self.htchar * indent)
def format_list(self, value, indent):
items = [
self.lfchar + self.htchar * (indent + 1) + (self.types[type(item) if type(item) in self.types else object])(self, item, indent + 1)
for item in value
]
return '[%s]' % (','.join(items) + self.lfchar + self.htchar * indent)
def format_tuple(self, value, indent):
items = [
self.lfchar + self.htchar * (indent + 1) + (self.types[type(item) if type(item) in self.types else object])(self, item, indent + 1)
for item in value
]
return '(%s)' % (','.join(items) + self.lfchar + self.htchar * indent)
Pour l'initialiser:
pretty = Formatter()
Il peut prendre en charge l'ajout de formateurs pour les types définis, il vous suffit de créer une fonction pour celle-ci comme celle-ci et de la lier au type souhaité avec set_formater:
from collections import OrderedDict
def format_ordereddict(self, value, indent):
items = [
self.lfchar + self.htchar * (indent + 1) +
"(" + repr(key) + ', ' + (self.types[
type(value[key]) if type(value[key]) in self.types else object
])(self, value[key], indent + 1) + ")"
for key in value
]
return 'OrderedDict([%s])' % (','.join(items) +
self.lfchar + self.htchar * indent)
pretty.set_formater(OrderedDict, format_ordereddict)
Pour des raisons historiques, je garde la jolie imprimante précédente qui était une fonction au lieu d'une classe, mais elles peuvent toutes les deux être utilisées de la même manière, la version de classe permet simplement beaucoup plus:
def pretty(value, htchar='\t', lfchar='\n', indent=0):
nlch = lfchar + htchar * (indent + 1)
if type(value) is dict:
items = [
nlch + repr(key) + ': ' + pretty(value[key], htchar, lfchar, indent + 1)
for key in value
]
return '{%s}' % (','.join(items) + lfchar + htchar * indent)
elif type(value) is list:
items = [
nlch + pretty(item, htchar, lfchar, indent + 1)
for item in value
]
return '[%s]' % (','.join(items) + lfchar + htchar * indent)
elif type(value) is tuple:
items = [
nlch + pretty(item, htchar, lfchar, indent + 1)
for item in value
]
return '(%s)' % (','.join(items) + lfchar + htchar * indent)
else:
return repr(value)
Pour l'utiliser :
>>> a = {'list':['a','b',1,2],'dict':{'a':1,2:'b'},'tuple':('a','b',1,2),'function':pretty,'unicode':u'\xa7',("tuple","key"):"valid"}
>>> a
{'function': <function pretty at 0x7fdf555809b0>, 'tuple': ('a', 'b', 1, 2), 'list': ['a', 'b', 1, 2], 'dict': {'a': 1, 2: 'b'}, 'unicode': u'\xa7', ('tuple', 'key'): 'valid'}
>>> print(pretty(a))
{
'function': <function pretty at 0x7fdf555809b0>,
'tuple': (
'a',
'b',
1,
2
),
'list': [
'a',
'b',
1,
2
],
'dict': {
'a': 1,
2: 'b'
},
'unicode': u'\xa7',
('tuple', 'key'): 'valid'
}
Par rapport aux autres versions:
- Cette solution recherche directement le type d'objet, vous pouvez donc imprimer à peu près tout, pas seulement la liste ou la dictée.
- N'a pas de dépendance.
- Tout est placé dans une chaîne, vous pouvez donc en faire ce que vous voulez.
- La classe et la fonction ont été testées et fonctionnent avec Python 2.7 et 3.4.
- Vous pouvez avoir tout type d'objets à l'intérieur, ce sont leurs représentations et non leur contenu qui est mis dans le résultat (donc la chaîne a des guillemets, la chaîne Unicode est entièrement représentée ...).
- Avec la version de classe, vous pouvez ajouter une mise en forme pour chaque type d'objet que vous souhaitez ou les modifier pour ceux déjà définis.
- La clé peut être de n'importe quel type valide.
- Le retrait et le caractère de nouvelle ligne peuvent être modifiés pour tout ce que nous souhaitons.
- Dict, List et Tuples sont joliment imprimés.