[PYTHON] Représenter des conteneurs dans un cadre imbriqué (schéma) dans Jupyter, et ce que j'ai étudié en cours de création
- Même si cela s'appelle un diagramme, il ne dessine pas d'arborescence de nœuds et ne fait rien de grand. Exprimez-le simplement dans un "cadre imbriqué".
Comment schématiser facilement un conteneur en Python? C'était le début, et à partir de là, j'ai pris note de ce que j'avais réalisé en utilisant le notebook Jupyter et de ce que je pensais être indirectement utile dans le processus de réalisation.
introduction
Ce n'est pas limité à Python, mais je me suis demandé s'il serait facile de préparer un diagramme visuellement facile à comprendre ou quelque chose lors de l'explication de données avec plusieurs conteneurs imbriqués (en particulier pour les débutants en programmation). C'était la raison pour laquelle j'ai fait ça.
Je ne suis pas satisfait de simplement préparer quelques échantillons sous forme d'images, alors je me suis demandé si le code pouvait être schématisé tel quel.
Dans un premier temps, traverser le conteneur pour faire une image? J'ai pensé, mais il semble difficile de calculer la partie qui exprime l'emboîtement ...
Mais quand j'y pense, cela m'est familier quand il s'agit d'exprimer la nidification. Oui, il est facile d'écrire en HTML et de l'afficher dans un navigateur Web.
Je commençais à peine à toucher Jupyter, donc ce serait mieux s'il pouvait être affiché sur Jupyter. Ensuite, pour faire des essais et des erreurs, le processus de conversion est transformé en module ...
À la suite de diverses réflexions comme celle-ci, il est devenu "affichage sous forme de cadre imbriqué en HTML".
Les liens des sites référencés sont affichés directement dans le texte.
Environnement de développement
- Python 3.5.1 | Anaconda 4.0.0 (64-bit)
- Windows 7 64bit
Je développe avec Windows7 + Anaconda (Python3), Tout fonctionnera tant que vous pourrez utiliser Python 3.5.1 et le notebook Jupyter.
Méthode de réalisation
En gros, tout ce que vous avez à faire est de parcourir le conteneur et de créer le HTML. Il y avait encore beaucoup de choses que je ne comprenais pas en Python, alors j'ai décidé de le faire par essais et erreurs. Notez certaines des choses que vous avez apprises au cours du processus.
Sortie HTML telle qu'elle est avec Jupyter
Vous pouvez utiliser le module IPython display pour générer du HTML directement dans les résultats Jupyter.
Module: display — IPython 4.2.0 documentation http://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html
--Exemple
from IPython.display import display, HTML
display(HTML('<p>Hello.</p>'))
Convertir des objets tels que des conteneurs en HTML
Parcourez le conteneur et convertissez-le en HTML. Il se transforme de manière récursive, ce qui entraîne une imbrication.
Comme il est difficile de comprendre l'apparence simplement en sortie en HTML, nous avons permis de distinguer plusieurs types par type de ligne et couleur. Ajoutez donc un style (classe) à la balise.
Créez un module nommé container2html pour convertir ces conteneurs en HTML.
Pour appliquer la définition de style, sortez la balise <style> au format HTML à l'avance.
Utiliser temporairement un module dans l'environnement local
Pour utiliser temporairement un module écrit localement, ajoutez un répertoire au chemin du module. Si vous ajoutez le répertoire du projet au chemin du module, vous pouvez l'importer comme un module normal.
Par exemple, j'écris un module dans PyCharm sous Windows en ce moment
Il existe un répertoire de projet C: \ Users \ argius \ PyCharm \ MyModule1
Et supposons que vous vouliez créer un fichier appelé container2html.py en dessous et en faire un module.
Dans ce cas, vous pouvez utiliser le module avec le nom c2h en procédant comme suit.
import sys
sys.path.append(r'C:\Users\argius\PyCharm\MyModule1')
import container2html as c2h
Module de rechargement
Une fois le module chargé, les mises à jour du code ne prendront effet qu'après son rechargement. Dans ce cas, c'est un processus d'essai et d'erreur, donc j'aimerais refléter la mise à jour chaque fois que je modifie le module ...
Dans ce cas, c'est-à-dire pour réévaluer le module modifié, utilisez la fonction reload du module ʻimport lib`.
import importlib
importlib.reload(c2h)
21/07/2016: J'utilisais l'ancien module ʻimp, donc je l'ai modifié en ʻimport lib.
Examiner la relation parent-enfant des types
Je voulais étudier la relation parent-enfant telle que le type de base afin qu'il puisse gérer des types inconnus dans une certaine mesure, mais au début je ne savais pas comment le faire.
Le site ci-dessous montre que vous pouvez le rechercher en utilisant la méthode mro.
Vous pouvez tracer les ancêtres de l'objet ʻo avec type (o) .mro () . Vous pouvez également spécifier directement le nom du type, tel que list.mro ()`.
Conseils Python: Je veux vérifier la relation d'héritage des classes - Life with Python http://www.lifewithpython.com/2014/08/python-check-class-inheritance-relationship.html
Par exemple, le Counter dans le module collections est similaire à un dictionnaire, mais pour voir s'il peut être interprété comme un dictionnaire, j'ai vérifié:
>>> from collections import Counter
>>> Counter.mro()
[<class 'collections.Counter'>, <class 'dict'>, <class 'object'>]
la mise en oeuvre
Module container2html.py
"""Container to HTML"""
def convert(o, **kwargs):
label = kwargs.get('label', None)
labelhtml = '' if label is None else '<p class="label">%s</p>' % label
return '<div class="c2h">%s %s</div>' % (labelhtml, HtmlConverter(kwargs).object_to_html(o))
def escape(o):
return str(o).replace('&', '&').replace('"', '"').replace('<', '<').replace('>', '>')
class HtmlConverter:
def __init__(self, kwargs):
self.options = kwargs
self.showtypeinfo = self.options.get('showtypeinfo', False)
def object_to_html(self, o):
def f():
if isinstance(o, dict):
return self.dict_to_html(o, 'dict')
t = type(o)
if t is tuple:
return self.seq_to_html(o, 'tuple')
if t is str:
return '<span class="value">%s</span>' % repr(o)
if t is list or hasattr(o, '__iter__'):
return self.seq_to_html(o, 'list')
return '<span class="value">%s</span>' % str(o)
if self.showtypeinfo:
return '<div class="typeinfo"><div>[%s]</div>%s</div>' % (escape(type(o).__name__), f())
return f()
o2html = object_to_html
def seq_to_html(self, seq, style_name=None):
a = list(seq)
if len(a) == 0:
return '<div style="nil">%s(empty)</div>' % ''
items = ['<li>%s</li>' % self.o2html(x) for x in a]
return '<ul class="%s">%s</ul>' % (style_name, ''.join(items))
def dict_to_html(self, d, style_name=None):
if len(d) == 0:
return '<ul class="%s"><li>(empty)</li></ul>' % style_name
items = ['<ul><li>%s</li><li>%s</li></ul>' % (self.o2html(k), self.o2html(v)) for k, v in d.items()]
return '<ul class="%s"><li>%s</li></ul>' % (style_name, ''.join(items))
style
div.c2h {
font-family: consolas, monospace;
border: 1px solid black;
margin: 0px 1px 3px 0px;
padding: 3px 1em;
}
div.c2h .label {
font-size: 100%;
color: blue;
text-decoration: underline;
padding-bottom: 1ex;
}
div.c2h span.value {
background-color: #fff;
padding: 1px 4px;
}
div.c2h div.typeinfo {
border: 1px dashed grey;
}
div.c2h ul {
border: 4px solid black;
display: table;
margin: 1ex;
padding-left: 0;
list-style: none;
text-align: center;
}
div.c2h ul li {
display:table-cell;
vertical-align: middle;
text-align:center;
padding: 1ex;
border-style: solid;
border-right-width: 4px;
border-top-width: 0px;
border-bottom-width: 0px;
}
div.c2h ul.list {
border-color: #cc3311;
}
div.c2h ul.list li {
border-color: #cc3311;
}
div.c2h ul.tuple {
border-color: #33bb33;
border-radius:10px;
}
div.c2h ul.tuple > li {
border-color: #33bb33;
}
div.c2h ul.dict {
border-color: #3333cc;
}
div.c2h ul.dict > li {
border-color: #3333cc;
}
div.c2h ul.dict > li ul {
border-color: #3333cc;
border-style: inset;
border-radius:10px;
}
div.c2h ul.dict > li ul li {
border-color: #3333ff;
border-width: 1px;
}
Résultat d'exécution
Préparez-vous à l'avance.
from IPython.display import display, HTML
import sys
sys.path.append(r'C:\Users\argius\PyCharm\MyModule1')
import container2html as c2h
display(HTML('''
<style>
(réduction)
</style>
'''))
Vous pouvez maintenant afficher le résultat de la fonction c2h.convert par display (HTML (...)).
C'est un problème d'écrire ceci à chaque fois, alors
Définissez une fonction v comme un raccourci qui génère la version convertie en HTML de la chaîne de caractères de code (expression) avec affichage.
def v(code, **kwargs):
display(HTML(c2h.convert(eval(code), label=code, **kwargs)))
Tout ce que vous avez à faire est de l'exécuter.
Code d'exécution
Si vous ajoutez showtypeinfo = True comme option, le nom du type sera également affiché.
v('[1, 2, (3, 4, 5)]')
v('[1, 2, (3, 4, 5)]', showtypeinfo=True)
v('zip([1, 2, 3, 4], [1, 2, 3, 4], [5, 6, 7, 8])', showtypeinfo=True)
v('dict(one=1, two=2)')
v('range(5)')
from collections import Counter
v("Counter(['a', 'a', 'b', 'c'])", showtypeinfo=True)
import numpy as np
v('np.arange(9).reshape(3, 3)', showtypeinfo=True)
résultat
«dict» est affiché dans un cadre bleu, «tuple» est affiché dans un cadre vert, et les autres «list» et autres «éditables» sont affichés dans un cadre rouge.
en conclusion
Je ne sais pas si cela sera réellement utilisé, mais je pense qu'il était plus significatif d'enquêter pour le faire. En fait, cette fois, j'ai eu plus de mal avec CSS qu'avec Python.
Surtout, c'est amusant de faire quelque chose par essais et erreurs comme ça!