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

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

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

The "pprint" module provides a capability to "pretty-print" arbitrary
Python data structures in a form which can be used as input to the
interpreter. If the formatted structures include objects which are not
fundamental Python types, the representation may not be loadable.
This may be the case if objects such as files, sockets or classes are
included, as well as many other objects which are not representable as
Python literals.

The formatted representation keeps objects on a single line if it can,
and breaks them onto multiple lines if they don't fit within the
allowed width, adjustable by the *width* parameter defaulting to 88
characters.

Modifié dans la version 3.9: Prise en charge de l’affichage élégant de
"types.SimpleNamespace".

Modifié dans la version 3.10: Prise en charge de l’affichage élégant
de "dataclasses.dataclass".


Fonctions
=========

pprint.pp(object, stream=None, indent=4, width=88, depth=None, *, compact=False, sort_dicts=False, underscore_numbers=False)

   Affiche la représentation formatée de *object*, suivie d’un retour
   à la ligne. Cette fonction peut être utilisée dans l’interpréteur
   interactif au lieu de la fonction "print()" pour inspecter les
   valeurs. Astuce : vous pouvez réassigner "print = pprint.pp" pour
   l’utiliser dans une portée.

   Paramètres:
      * **object** -- L’objet à afficher.

      * **stream** (*file-like object* | None) -- Un objet fichier-
        compatible sur lequel la sortie sera écrite en appelant sa
        méthode "write()". Si la valeur est "None" (la valeur par
        défaut), "sys.stdout" est utilisé.

      * **indent** (*int*) -- La quantité d’indentation ajoutée pour
        chaque niveau d’imbrication.

      * **width** (*int*) -- Le nombre maximal de caractères souhaités
        par ligne dans la sortie. Si une structure ne peut pas être
        formatée dans la largeur limite donnée, un effort maximal sera
        fait.

      * **depth** (*int** | **None*) -- Le nombre de niveaux
        d’imbrication qui peuvent être affichés. Si la structure de
        données à afficher est trop profonde, le niveau suivant est
        remplacé par "...". Si la valeur est "None" (la valeur par
        défaut), il n’y a pas de contrainte sur la profondeur des
        objets formatés.

      * **compact** (*bool*) -- Control the way long *sequences* are
        formatted. If "False" (the default), opening parentheses and
        brackets will be followed by a newline and the following
        content will be indented by one level, similar to pretty-
        printed JSON. If "True", as many items as will fit within the
        *width* will be formatted on each output line.

      * **sort_dicts** (*bool*) -- Si la valeur est "True", les
        dictionnaires seront formatés avec leurs clés triées, sinon
        ils seront affichés dans l'ordre d'insertion (la valeur par
        défaut).

      * **underscore_numbers** (*bool*) -- Si la valeur est "True",
        les entiers seront formatés avec le caractère "_" comme
        séparateur de milliers, sinon les underscores ne sont pas
        affichés (le comportement par défaut).

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

   Ajouté dans la version 3.8.

pprint.pprint(object, stream=None, indent=4, width=88, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

   Alias pour "pp()" avec *sort_dicts* initialisé à "True" par défaut
   (ce qui trie automatiquement les clés des dictionnaires), vous
   pourriez préférer utiliser "pp()" à la place où *sort_dicts* est
   initialisé à "False" par défaut.

pprint.pformat(object, indent=4, width=88, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

   Renvoie une représentation formatée de *object* sous forme de
   chaîne de caractères. *indent*, *width*, *depth*, *compact*,
   *sort_dicts* et  *underscore_numbers* sont passés au constructeur
   de "PrettyPrinter" comme paramètres de formatage et leurs
   significations sont telles que décrites dans la documentation ci-
   dessus.

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* nécessite une représentation récursive. Cette
   fonction est soumise aux mêmes limitations que celles notées dans
   "saferepr()" ci-dessous et peut lever une exception
   "RecursionError" si elle échoue à détecter un objet récursif.

pprint.saferepr(object)

   Renvoie une représentation de *object*, protégée contre la
   récursivité dans certaines structures de données courantes, à
   savoir que les instances de "dict", "list" et "tuple" ou les sous-
   classes dont la méthode "__repr__" n’ont pas été surchargées. 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']"


PrettyPrinter objects
=====================

class pprint.PrettyPrinter(indent=4, width=88, depth=None, stream=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

   Crée une instance de "PrettyPrinter".

   Les arguments ont la même signification que pour "pp()". Notez
   qu’ils sont dans un ordre différent, et que *sort_dicts* est
   initialisé à "True" par défaut.

   >>> import pprint
   >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
   >>> stuff.insert(0, stuff[:])
   >>> pp = pprint.PrettyPrinter()
   >>> pp.pprint(stuff)
   [
       ['spam', 'eggs', 'lumberjack', 'knights', 'ni'],
       'spam',
       'eggs',
       'lumberjack',
       'knights',
       'ni',
   ]
   >>> pp = pprint.PrettyPrinter(indent=1, width=41, compact=True)
   >>> pp.pprint(stuff)
   [['spam', 'eggs', 'lumberjack',
     'knights', 'ni'],
    'spam', 'eggs', 'lumberjack', 'knights',
    'ni']
   >>> pp = pprint.PrettyPrinter(width=41, indent=3)
   >>> 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', (...)))))))

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

   Modifié dans la version 3.8: Ajout du paramètre *sort_dicts*.

   Modifié dans la version 3.10: Ajout du paramètre
   *underscore_numbers*.

   Modifié dans la version 3.11: N'essaie plus d’écrire sur
   "sys.stdout" lorsqu'il vaut "None".

   Modifié dans la version 3.15: Changed default *indent* from 1 to 4
   and default *width* from 80 to 88. The default "compact=False"
   layout is now similar to pretty-printed JSON, with opening
   parentheses and brackets followed by a newline and the contents
   indented by one level.

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.


Exemple
=======

Pour illustrer quelques cas pratiques de l’utilisation de la fonction
"pp()" 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/1.2.0/json') as resp:
   ...     project_info = json.load(resp)['info']

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

   >>> pprint.pp(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.pp(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.pp(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',
   }
