8.11. "pprint" — L’affichage élégant de données
***********************************************

**Code source :** Lib/pprint.py

======================================================================

Le module "pprint" permet « d’afficher élégamment » des structures de
données Python arbitraires sous une forme qui peut être utilisée
ensuite comme une entrée dans l’interpréteur. Si les structures
formatées incluent des objets qui ne sont pas des types Python
fondamentaux, leurs représentations peuvent ne pas être acceptables en
tant que telles par l’interpréteur. Cela peut être le cas si des
objets tels que des fichiers, des interfaces de connexion (*sockets*
en anglais) ou des classes sont inclus, c’est aussi valable pour
beaucoup d’autres types d’objets qui ne peuvent être représentés sous
forme littérale en Python.

L’affichage formaté affiche tant que possible les objets sur une seule
ligne, et les sépare sur plusieurs lignes s’ils dépassent la largeur
autorisée par l’interpréteur. Créez explicitement des objets
"PrettyPrinter" si vous avez besoin de modifier les limites de
largeur.

Les dictionnaires sont classés par clés avant que l’affichage ne soit
calculé.

Le module "pprint" définit une seule classe :

class pprint.PrettyPrinter(indent=1, width=80, depth=None, stream=None, *, compact=False)

   Crée une instance de "PrettyPrinter".  Ce constructeur accepte
   plusieurs paramètres nommés.  Un flux de sortie peut être défini
   par le mot clé *stream*; la seule méthode utilisée sur l’objet
   *stream* est la méthode "write()" du protocole de fichiers.  Si
   rien n’est spécifié, la classe "PrettyPrinter" utilise
   "sys.stdout".  La taille de l’indentation ajoutée à chaque niveau
   récursif est spécifiée par *indent*; la valeur par défaut vaut "1`.
   D’autres valeurs pourraient donner des résultats surprenants, mais
   peuvent aider à mieux visualiser les imbrications.  Le nombre de
   niveaux qui peuvent être affichés est contrôlé par *depth*; si la
   structure de données est trop profonde, le niveau suivant est
   remplacé par ``…".  Par défaut il n’y a pas de contraintes sur la
   profondeur des objets formatés.  Vous pouvez limiter la largeur de
   la sortie à l’aide du paramètre *width*; la valeur par défaut est
   de 80 caractères. Si une structure ne peut pas être formatée dans
   les limites de la largeur contrainte, le module fait au mieux.  SI
   *compact* est initialisé à *False* (la valeur par défaut), chaque
   élément d’une longue séquence est formaté sur une ligne séparée.
   Si *compact* est initialisé à *True*, tous les éléments qui peuvent
   tenir dans la largeur définie sont formatés sur chaque ligne de
   sortie.

   Modifié dans la version 3.4: Ajout du paramètre *compact*.

   >>> import pprint
   >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
   >>> stuff.insert(0, stuff[:])
   >>> pp = pprint.PrettyPrinter(indent=4)
   >>> pp.pprint(stuff)
   [   ['spam', 'eggs', 'lumberjack', 'knights', 'ni'],
       'spam',
       'eggs',
       'lumberjack',
       'knights',
       'ni']
   >>> pp = pprint.PrettyPrinter(width=41, compact=True)
   >>> pp.pprint(stuff)
   [['spam', 'eggs', 'lumberjack',
     'knights', 'ni'],
    'spam', 'eggs', 'lumberjack', 'knights',
    'ni']
   >>> tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',
   ... ('parrot', ('fresh fruit',))))))))
   >>> pp = pprint.PrettyPrinter(depth=6)
   >>> pp.pprint(tup)
   ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead', (...)))))))

Le module "pprint" fournit aussi quelques fonctions de raccourcis :

pprint.pformat(object, indent=1, width=80, depth=None, *, compact=False)

   Renvoie une représentation formatée de *object* sous forme de
   chaine de caractères. *indent*, *width*, *depth* et *compact* sont
   passés au constructeur de "PrettyPrinter" comme paramètres de
   formatage.

   Modifié dans la version 3.4: Ajout du paramètre *compact*.

pprint.pprint(object, stream=None, indent=1, width=80, depth=None, *, compact=False)

   Affiche la représentation formatée de *object* sur *stream*, suivie
   d’un retour à la ligne. Si *stream* vaut "None", "sys.stdout" est
   alors utilisé. Vous pouvez l’utiliser dans l’interpréteur
   interactif de Python au lieu de la fonction "print()" pour
   inspecter les valeurs (vous pouvez même réassigner "print =
   pprint.pprint" pour une utilisation au sein de sa portée).
   *indent*, *width*, *depth* et *compact* sont passés au constructeur
   de classe "PrettyPrinter" comme paramètres de formatage.

   Modifié dans la version 3.4: Ajout du paramètre *compact*.

   >>> import pprint
   >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
   >>> stuff.insert(0, stuff)
   >>> pprint.pprint(stuff)
   [<Recursion on list with id=...>,
    'spam',
    'eggs',
    'lumberjack',
    'knights',
    'ni']

pprint.isreadable(object)

   Détermine si la représentation formatée de *object* est « lisible
   », ou s’il peut être utilisé pour recomposer sa valeur en utilisant
   la fonction "eval()". Cela renvoie toujours "False" pour les objets
   récursifs.

   >>> pprint.isreadable(stuff)
   False

pprint.isrecursive(object)

   Détermine si *object* requiert une représentation récursive.

Une dernière fonction de support est définie ainsi :

pprint.saferepr(object)

   Renvoie une représentation de *object* sous forme de chaîne de
   caractère, celle-ci est protégée contre les structures de données
   récursives. Si la représentation de *object* présente une entrée
   récursive, celle-ci sera représentée telle que "<Recursion on
   typename with id=number>". Par ailleurs, la représentation de
   l’objet n’est pas formatée.

   >>> pprint.saferepr(stuff)
   "[<Recursion on list with id=...>, 'spam', 'eggs', 'lumberjack', 'knights', 'ni']"


8.11.1. Les Objets PrettyPrinter
================================

Les instances de la classe "PrettyPrinter" ont les méthodes suivantes
:

PrettyPrinter.pformat(object)

   Renvoie la représentation formatée de *object*. Cela prend en
   compte les options passées au constructeur de la classe
   "PrettyPrinter".

PrettyPrinter.pprint(object)

   Affiche sur le flux configuré la représentation formatée de
   *object*, suivie d’une fin de ligne.

Les méthodes suivantes fournissent les implémentations pour les
fonctions correspondantes de mêmes noms. L’utilisation de ces méthodes
sur une instance est légèrement plus efficace, car les nouveaux objets
"PrettyPrinter" n’ont pas besoin d’être créés.

PrettyPrinter.isreadable(object)

   Détermine si la représentation formatée de *object* est « lisible
   », ou si elle peut être utilisée pour recomposer sa valeur en
   utilisant la fonction "eval()". Cela renvoie toujours "False" pour
   les objets récursifs. Si le paramètre *depth* de la classe
   "PrettyPrinter" est initialisé et que l’objet est plus « profond »
   que permis, cela renvoie "False".

PrettyPrinter.isrecursive(object)

   Détermine si l’objet nécessite une représentation récursive.

Cette méthode est fournie sous forme de point d’entrée ou méthode (à
déclenchement) automatique (*hook* en anglais) pour permettre aux
sous-classes de modifier la façon dont les objets sont convertis en
chaînes. L’implémentation par défaut est celle de la fonction
"saferepr()".

PrettyPrinter.format(object, context, maxlevels, level)

   Renvoie trois valeurs : la version formatée de *object* sous forme
   de chaîne de caractères, une option indiquant si le résultat est «
   lisible », et une option indiquant si une récursion a été détectée.
   Le premier argument est l’objet à représenter. Le deuxième est un
   dictionnaire qui contient l'"id()" des objets (conteneurs directs
   ou indirects de *objet* qui affectent sa représentation) qui font
   partie du contexte de représentation courant tel que les clés; si
   un objet doit être représenté, mais l’a déjà été dans ce contexte,
   le troisième argument renvoie "True". Des appels récursifs à la
   méthode "format()" doivent ajouter des entrés additionnelles aux
   conteneurs de ce dictionnaire. Le troisième argument *maxlevels*,
   donne la limite maximale de récursivité; la valeur par défaut est
   "0". Cet argument doit être passé non modifié pour des appels non
   récursifs. Le quatrième argument, *level*, donne le niveau de
   récursivité courant; les appels récursifs doivent être passés à une
   valeur inférieure à celle de l’appel courant.


8.11.2. Exemple
===============

Pour illustrer quelques cas pratiques de l’utilisation de la fonction
"pprint()" et de ses paramètres, allons chercher des informations sur
un projet PyPI :

   >>> import json
   >>> import pprint
   >>> from urllib.request import urlopen
   >>> with urlopen('https://pypi.org/pypi/sampleproject/json') as resp:
   ...     project_info = json.load(resp)['info']

Dans sa forme basique, la fonction "pprint()" affiche l’intégralité de
l’objet :

   >>> pprint.pprint(project_info)
   {'author': 'The Python Packaging Authority',
    'author_email': 'pypa-dev@googlegroups.com',
    'bugtrack_url': None,
    'classifiers': ['Development Status :: 3 - Alpha',
                    'Intended Audience :: Developers',
                    'License :: OSI Approved :: MIT License',
                    'Programming Language :: Python :: 2',
                    'Programming Language :: Python :: 2.6',
                    'Programming Language :: Python :: 2.7',
                    'Programming Language :: Python :: 3',
                    'Programming Language :: Python :: 3.2',
                    'Programming Language :: Python :: 3.3',
                    'Programming Language :: Python :: 3.4',
                    'Topic :: Software Development :: Build Tools'],
    'description': 'A sample Python project\n'
                   '=======================\n'
                   '\n'
                   'This is the description file for the project.\n'
                   '\n'
                   'The file should use UTF-8 encoding and be written using '
                   'ReStructured Text. It\n'
                   'will be used to generate the project webpage on PyPI, and '
                   'should be written for\n'
                   'that purpose.\n'
                   '\n'
                   'Typical contents for this file would include an overview of '
                   'the project, basic\n'
                   'usage examples, etc. Generally, including the project '
                   'changelog in here is not\n'
                   'a good idea, although a simple "What\'s New" section for the '
                   'most recent version\n'
                   'may be appropriate.',
    'description_content_type': None,
    'docs_url': None,
    'download_url': 'UNKNOWN',
    'downloads': {'last_day': -1, 'last_month': -1, 'last_week': -1},
    'home_page': 'https://github.com/pypa/sampleproject',
    'keywords': 'sample setuptools development',
    'license': 'MIT',
    'maintainer': None,
    'maintainer_email': None,
    'name': 'sampleproject',
    'package_url': 'https://pypi.org/project/sampleproject/',
    'platform': 'UNKNOWN',
    'project_url': 'https://pypi.org/project/sampleproject/',
    'project_urls': {'Download': 'UNKNOWN',
                     'Homepage': 'https://github.com/pypa/sampleproject'},
    'release_url': 'https://pypi.org/project/sampleproject/1.2.0/',
    'requires_dist': None,
    'requires_python': None,
    'summary': 'A sample Python project',
    'version': '1.2.0'}

Le résultat peut être limité à une certaine profondeur en initialisant
*depth*. ( "…" est utilisé pour des contenus plus « profonds ») :

   >>> pprint.pprint(project_info, depth=1)
   {'author': 'The Python Packaging Authority',
    'author_email': 'pypa-dev@googlegroups.com',
    'bugtrack_url': None,
    'classifiers': [...],
    'description': 'A sample Python project\n'
                   '=======================\n'
                   '\n'
                   'This is the description file for the project.\n'
                   '\n'
                   'The file should use UTF-8 encoding and be written using '
                   'ReStructured Text. It\n'
                   'will be used to generate the project webpage on PyPI, and '
                   'should be written for\n'
                   'that purpose.\n'
                   '\n'
                   'Typical contents for this file would include an overview of '
                   'the project, basic\n'
                   'usage examples, etc. Generally, including the project '
                   'changelog in here is not\n'
                   'a good idea, although a simple "What\'s New" section for the '
                   'most recent version\n'
                   'may be appropriate.',
    'description_content_type': None,
    'docs_url': None,
    'download_url': 'UNKNOWN',
    'downloads': {...},
    'home_page': 'https://github.com/pypa/sampleproject',
    'keywords': 'sample setuptools development',
    'license': 'MIT',
    'maintainer': None,
    'maintainer_email': None,
    'name': 'sampleproject',
    'package_url': 'https://pypi.org/project/sampleproject/',
    'platform': 'UNKNOWN',
    'project_url': 'https://pypi.org/project/sampleproject/',
    'project_urls': {...},
    'release_url': 'https://pypi.org/project/sampleproject/1.2.0/',
    'requires_dist': None,
    'requires_python': None,
    'summary': 'A sample Python project',
    'version': '1.2.0'}

De plus, une valeur maximale de caractères sur une ligne peut être
définie en initialisant le paramètre *width*. Si un long objet ne peut
être scindé, la valeur donnée à *width* sera outrepassée :

   >>> pprint.pprint(project_info, depth=1, width=60)
   {'author': 'The Python Packaging Authority',
    'author_email': 'pypa-dev@googlegroups.com',
    'bugtrack_url': None,
    'classifiers': [...],
    'description': 'A sample Python project\n'
                   '=======================\n'
                   '\n'
                   'This is the description file for the '
                   'project.\n'
                   '\n'
                   'The file should use UTF-8 encoding and be '
                   'written using ReStructured Text. It\n'
                   'will be used to generate the project '
                   'webpage on PyPI, and should be written '
                   'for\n'
                   'that purpose.\n'
                   '\n'
                   'Typical contents for this file would '
                   'include an overview of the project, '
                   'basic\n'
                   'usage examples, etc. Generally, including '
                   'the project changelog in here is not\n'
                   'a good idea, although a simple "What\'s '
                   'New" section for the most recent version\n'
                   'may be appropriate.',
    'description_content_type': None,
    'docs_url': None,
    'download_url': 'UNKNOWN',
    'downloads': {...},
    'home_page': 'https://github.com/pypa/sampleproject',
    'keywords': 'sample setuptools development',
    'license': 'MIT',
    'maintainer': None,
    'maintainer_email': None,
    'name': 'sampleproject',
    'package_url': 'https://pypi.org/project/sampleproject/',
    'platform': 'UNKNOWN',
    'project_url': 'https://pypi.org/project/sampleproject/',
    'project_urls': {...},
    'release_url': 'https://pypi.org/project/sampleproject/1.2.0/',
    'requires_dist': None,
    'requires_python': None,
    'summary': 'A sample Python project',
    'version': '1.2.0'}
