Donnez-moi un levier, un point d'appui, un espace pour les jambes et du ruban renforcé
Même si vous essayez, vous ne pouvez pas décrire succinctement comment un trou de lapin sans fond vous attend. Voici l'un de ces rares cas où, pour réaliser ce qui sera discuté, il est nécessaire d'écouter le discours jusqu'au bout. Après avoir étudié les étapes de ce manuel, chacun trouvera quelque chose pour lui-même: l'éditeur de «texte» ésotérique Leo Editor avec toute son essence appelle à son utilisation de la manière la plus étonnante.
Table des matières
1. Prologue ................................... 2
2. Installation de Leo Editor ..................... 2
3. Configuration ................................ 4
4. Familiarisation avec l'interface ........... 7
5. Création de fichiers externes ................. 14
6. Utilisation des sections nommées ........ 18
7. Inclusion gourmande ........................ 21
8. Magie simple ...................... 24
9. Le revers du loup-garou ............... 30
10. Visualisez ceci ........................ 33
11. Contenu et forme ...................... 36
12. Je vais créer un IDE pour moi-même .................... 39
13. Liberté de pensée ........................... 49
14. Hourra, la fin .............................. 58
15. UPD. Exemples d'application ................. 58
Prologue
Lorsque vous écrivez dans n'importe quel langage de programmation, il y a toujours une pénurie aiguë du navigateur de classe de Smalltalk, le sentiment ennuyeux que vos mains sont liées et vos jambes humides est sans fin. Et il arrive aussi que vous cherchiez souvent une chose sur Internet, et que vous trouviez quelque chose de complètement différent, mais si beau que la raison du début de la recherche se perd dans le contexte des horizons en cours. Une recherche de l'expression «navigateur de classe python» donne une tonne de détritus, mais un diamant non taillé se trouve dans cette montagne, scintillant faiblement, n'attirant pas un large intérêt, attendant que l'œil attentif et un esprit curieux le remarquent et le ramassent.
Installer Leo Editor
Le projet est multi-plateforme, le processus d'installation est prévu pour la plateforme Windows. Pour démarrer l'éditeur, vous avez besoin de Python et de la bibliothèque Qt. L'option d'installation décrite est la plus simple pour l'utilisateur non préparé à la souffrance, les professionnels peuvent agir à leur discrétion.
Installez le gestionnaire d'espace de travail du programmeur python Miniconda. Cette solution vous permet de réduire considérablement la possibilité d'obtenir une citrouille au lieu de composants correctement connectés, et dans le cas d'un blocage arbitraire, revenez sans douleur à l'état zéro et passez rapidement à tester une option de réglage différente.
Depuis la page de
téléchargement, nous
téléchargeons le programme d' installation de Python 3.7 Miniconda3 Windows 64 bits. Nous réglons la question des coches lorsque nous activons les deux.
Ensuite, exécutez la ligne de commande (touches [Win + R], "cmd", [Entrée]). Nous tapons:
conda
Il n'y a aucune erreur, il y a un accès direct à conda. Nous vérifions la disponibilité de la version requise de l'exécuteur de langage:
python -V
Sur place.
Nous regardons quelles versions de l'éditeur sont disponibles pour l'installation:
pip install leo==
Nous préférons la dernière version sans lettres dans le numéro:
pip install leo==6.1
Après le téléchargement, le déballage et l'installation, nous tentons notre chance: nous lançons l'interpréteur python, nous connectons aux composants de l'éditeur, démarrons l'éditeur
python >>>import leo >>>leo.run()
Personnalisation
Si le raccourci pour le lancement n'apparaît pas sur le bureau, ajoutez-le vous-même:
Chemin d'accès au
lanceur d' éditeur:
% USERPROFILE% \ Miniconda3 \ Scripts \ leo.exeChemin de l'
icône :
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ Icons \ SplashScreen_trans.ico
Je n'aimais pas vraiment l'apparence de mes thèmes visuels natifs, j'ai donc dû créer les miens. Pour l'utiliser, vous devez d'abord le
télécharger . Sans virus 1000%. Le fichier
python.py est une description des éléments de syntaxe python qui différencient les couleurs. Il doit être placé dans
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ modes \ avec le remplacement du fichier précédent. Ce qui, pour vous, a abandonné le langage python, deviendra clair un peu plus tard. Les fichiers restants de l'archive doivent être copiés dans le
dossier% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ themes \ .
Vous devez maintenant activer le thème dans les paramètres utilisateur.
Cliquez sur l'élément @settings, puis utilisez la touche [Insérer] pour ajouter un nouvel élément imbriqué. Collez le texte:
@string theme-name = monokai.leo
Pour enregistrer les modifications, appuyez sur [Entrée]. Si la modification du nom d'un élément est désactivée par inadvertance, vous pouvez l'activer en double-cliquant sur l'élément ou en appuyant sur la combinaison [Ctrl + h].
Redémarrez en enregistrant les modifications.
L'association avec les fichiers ".leo" devrait se produire automatiquement, mais sinon, nous utiliserons la solution intégrée.
Jusqu'à récemment, cela n'a pas fonctionné sans amendements, et maintenant ils ont réparé, comme si, hehe.
Connaître l'interface
À première vue, nous avons devant nous un éditeur ordinaire de textes structurés (éditeur de contours anglais, Outliner), un clone du
treepad bien-aimé par beaucoup (l'archive Web, hors site, malheureusement, a été désactivée en raison de problèmes financiers du développeur). En effet, il y a un arbre et il y a une zone de saisie de texte qui appartient au nœud d'arbre sélectionné. La zone multifonctionnelle avec les onglets de nom simples, en plus du journal, conclut quelque chose d'autre utile, commençons par la recherche de texte.
Cela semble être une chose stéréotypée, mais il y a des excentricités, au lieu de boutons à l'écran, il est proposé d'appuyer sur les touches du clavier. Et la commande find-all n'a pas du tout de clé affectée. Maintenant, toute l'attention est au bas de la fenêtre.
Les Tru-geeks doivent s'être étouffés avec de la bière. Oui les gars, c'est un emprunt direct à emacs. La plupart des opérations de l'éditeur peuvent être démarrées à l'aide de la ligne de commande intégrée.
Les résultats de la recherche pour tous les mots apparaissant «le» sont affichés dans un nouveau nœud d'arbre délibérément créé. La ferme collective! (Ne vous inquiétez pas, la recherche par élément "parcourt" les occurrences détectées, comme dans les oncles sains).
Jeunes, ne vous dispersez pas! Il fallait secouer les cloques endormies. Vous pouvez toujours contourner le bord de cette zone sombre Leo Editor. Le programme ressemble beaucoup à Linux: passion, combien tout fait par divers passionnés pour eux-mêmes, tout cela nécessite une étude réfléchie, les performances de l'un sont différentes de la mise en œuvre de l'autre, il est toujours surprenant de découvrir de nouvelles puces que quelqu'un a mises, mais n'a pas vraiment décrites, et quand pour tout cela, il y a la pointe de l'iceberg sur laquelle il repose confortablement, et si vous hésitez à partir à l'aventure, vous ne pouvez pas vous envelopper dans des profondeurs sombres.
La zone de balise vous permet d'attribuer des étiquettes aux nœuds et de travailler ensuite avec eux. Apparemment utilisé pour ajouter de nouvelles dimensions à la profondeur de l'ordre du chaos. Nous sélectionnons le nœud, écrivons l'identifiant de la balise, cliquez sur "+". Nous sélectionnons un autre nœud, appuyez simplement sur "+", le tag actif sera attribué. Nous sélectionnons le troisième nœud, écrivons "Schmucker", appuyez sur "+". Nous avons actuellement deux nœuds avec le tag "zutsker" et un nœud avec le tag "shmutsker".
La sélection d'une balise dans la liste des balises conduit à une liste de nœuds associés à la balise sous les noms desquels vous pouvez naviguer. Pour sélectionner une balise dans un nœud, faites un clic droit dessus.
Vient ensuite le panneau Nav extrêmement utile. Il aide à ignorer rapidement les nœuds dans lesquels un certain mot apparaît. Étant donné que la manière de gérer les fichiers .leo est un grand gâchis avec un haut niveau d'organisation, la navigation dans la recherche s'inscrit dans le cycle naturel de l'application.
L'utilisation courante des éditeurs de textes structurels est l'accumulation d'une base de connaissances personnelles. La deuxième utilisation la plus courante consiste à maintenir une liste de tâches. L'onglet suivant permet de coloriser ce processus avec des priorités, des délais et des statuts d'implémentation.
Le menu contextuel du nœud vous permet d'utiliser une proportion importante des capacités de l'onglet Tâche.
Créer des fichiers externes
Comment éditer le texte et utiliser l'arbre ne sera pas difficile à comprendre par vous-même, nous allons donc plonger dans l'abîme des possibilités infinies de transfert des abstractions dans le monde réel. Créez un nouveau fichier.
Le nom du nœud unique
NewHeadline changé en
@file 1.txt
Ajoutez du texte au contenu du nœud.
Enregistrez le fichier .leo quelque part. Ouvrez le dossier dans lequel se trouve le fichier .leo. On y remarque 1.txt. Nous l'ouvrons.
Qu'avons-nous construit? Nous avons configuré l'exportation d'un des nœuds du fichier .leo vers un fichier externe.
Quelle poubelle est autour de notre texte? Métadonnées qui vous permettent de recréer la structure lors du chargement du fichier dans l'éditeur Leo, ce qui est nécessaire si le fichier sera modifié quelque part à l'extérieur. La plupart des fichiers python du code source de Leo Editor peuvent être déposés par glisser-déposer dans l'éditeur et ont constaté qu'ils contiennent une description de la structure:
Mais si nous n'avons pas du tout besoin de la fonction de téléchargement inversé, mais au contraire que le fichier ne contienne pas d'octets étrangers, alors cela se fait en remplaçant la directive
@file par
@file-nosent (pas de sentinelles).
Après avoir enregistré les modifications dans le fichier .leo, le fichier externe sera automatiquement mis à jour.
Utilisation de sections nommées
Chaque nœud est une entité indépendante distincte, qui par défaut ne dispose pas d'informations sur ses voisins. Si nous essayons d'ajouter une nouvelle structure au nœud attaché à un fichier externe et cliquez sur Enregistrer, une erreur se produira.
Nous sommes informés de deux problèmes:
- Nous avons un nœud «test» suspendu dans l'air (par rapport au fichier externe, car il y a un nœud à l'intérieur de la structure .leo, mais nous n'avons pas indiqué comment il devrait être ajouté au fichier externe, à cause de cela il y a une erreur).
- Jusqu'à ce que le problème avec le nœud suspendu soit résolu, aucune autre modification à l'intérieur du
@file-nosent 1.txt ne sera enregistrée sur le disque.
La première façon d'ajouter des liens entre les nœuds consiste à utiliser des sections. Un format spécial pour les noms de section ressemble à ceci:
<<my_name>>
Cela vous permet de proclamer un nœud imbriqué en tant que section nommée, le même nom doit être spécifié à la place du nœud externe où le contenu du nœud subordonné doit être placé.
Le fichier résultant:
Le même exemple sur un fichier réel, la section d'importation des dépendances externes est explicitement allouée à un nœud distinct.
Inclusion gourmande
Mais que faire si nous voulons construire une section imbriquée dans une section imbriquée et y mettre une autre section? Vous pouvez agir naïvement:
Mais pour de tels désirs naturels, il y a jusqu'à deux directives:
@all et
@others .
La directive
@all concatène insipide les textes de tous les nœuds imbriqués.
Bien sûr, tout dépend du format de fichier dont vous avez besoin à la sortie, mais vous aimerez
@others directive
@others , qui vous permet de matérialiser la structure conçue sous la forme souhaitée. Option mélancolique:
Emballage des sections avec des mots clés:
Formatage de l'indentation:
Comment? Commence-t-il à prendre forme? On s'amuse à peine.
:: ::
Magie simple
Enfin, nous commençons à composer le code. La tâche sera stupide, mais contenant des éléments de base typiques d'un programme utile. Créez un nouveau nœud n'importe où dans le fichier existant ou nouveau. La première ligne indique la directive
@language pour activer la mise en évidence du code. Si sous votre langue de surbrillance dans le dossier
% USERPROFILE% \ Miniconda3 \ Lib \ site-packages \ leo \ modes \ no, personne n'interdit de l'ajouter vous-même.
Supposons que les informations que nous allons traiter soient stockées par une plaque dans un fichier csv.
Nous devons: compter le nombre de caractères "0" trouvés dans la colonne Count
Nous devons:
- Convertir du texte en exemple de structure de données
- Effectuer une itération avec comptage
Nous décomposons le programme selon l'algorithme développé. La deuxième étape après la lecture du fichier, divisez le texte en lignes. Quelle a été la première étape se déplace vers le nœud subordonné de lecture.
Ensuite, créez un tableau de dictionnaires correspondant aux données du tableau. Ce nœud est au niveau supérieur.
Et la dernière étape.
En attendant, le fichier main.py résultant se formera sur le disque.
Hourra, nous sommes super. Mais tout à coup, nous avons eu un désir incompréhensible de calculer le nombre de lignes significatives dans le même fichier csv. Pas de problème, faites copy.paste du noeud principal, changez le nom du fichier de sortie, modifiez le code de la dernière étape. Nous obtenons le résultat.
Et ici, notre joie cède la place à la tristesse, car le nom du fichier CSV peut devenir différent, ce qui signifie que si nous le corrigeons dans un programme, alors dans le second, nous le perdrons définitivement de vue et déprécierons ainsi la joie de réutiliser le code.
Triste et jolie, c'est Leo Editor! Il a synchronisé des copies de nœuds. Quoi? Au lieu de copier le contenu du nœud, vous pouvez coller le nœud copié en mode "clone", "fantôme", puis changer l'un des nœuds liés sera affiché sur les autres nœuds. Il s'agit d'un concept extrêmement puissant qui vous permet de résoudre les contradictions inhérentes à l'organisation des informations dans les arbres.
Copiez le nœud.
Nous insérons comme un «fantôme».
Les fantômes ont une icône différente. Toute modification du nom, du contenu ou des nœuds subordonnés est reflétée dans la copie. Nous supprimons l'ancien nœud de lecture et vérifions que la modification du nom de fichier est maintenant effectuée de manière synchrone partout.
Parlant dans le langage des mathématiques, les «fantômes» vous permettent de passer d'un arbre à un graphique acyclique à part entière. Un arbre en Lion peut avoir plus d'une racine!
Cela vous permet de faire des choses fantastiques: jongler avec des représentations d'informations, lier des conteneurs de données hétérogènes, disposer d'un nombre infini de copies réelles de données dans un projet, charger des données dans l'arborescence Leo qui ne peuvent pas être placées dans une arborescence régulière.
Loup-garou inversé
Faisons une expérience. Créez un nouveau nœud. Ajoutez-y du texte.
g.es( len("This is test".split()) )
Appuyez sur [Ctrl] + [b].
Chpok, bonne soirée. Oui, ici, il s'avère que l'interpréteur Python est intégré, ce qui peut exécuter le texte du nœud en tant que code. Si les sections sont connectées au nœud selon les règles de jonction des sections aux fichiers externes, le code qui en découle est également exécuté, ce qui signifie qu'il n'y a pas une telle force qu'il peut nous arrêter dans une bataille contre le désordre.
Exemple de vie: le code des didacticiels est terriblement réticent à écrire normalement, mais s'il s'agit de plus de 50 lignes, le désordre qui devient illisible le lendemain est garanti. Il convient d'ajouter que de nombreux formateurs utilisent le même ensemble de données source, effectuant diverses manipulations sur eux. Ce qui précède est vrai pour tout "prototype" ou "utilitaire d'outil 1-2 fois". À cet endroit, les puces Leo Editor décrites sont extrêmement utiles.
C'est tout - c'est du code qui fait quelque chose directement dans l'éditeur Leo, sans le télécharger dans des fichiers .py.
Contrairement aux feuilles de spaghetti sur l'image, vous pouvez immédiatement comprendre l'essence générale de ce qui se passe. Par exemple, dans le programme «4 Linear Regression», les données d'Internet sont d'abord écrites dans un fichier. Et puis diverses manipulations sont effectuées sur le modèle numérique de «régression OLS», construit selon le fichier. De plus, si nous devons utiliser d'autres données ou d'autres paramètres du modèle, il suffit alors de faire des changements dans un nœud, car les parties réutilisées du programme sont implémentées par des «fantômes». Le programme est divisé en 6 parties indépendantes, chacune étant lancée séparément, mais en même temps, elles commencent à être exécutées à partir d'un point commun.
Lorsque le code de sujets similaires est organisé de manière organisée en un seul endroit, cela est très pratique, même si beaucoup de temps passe, puis en utilisant la recherche de navigation, vous pouvez rapidement trouver une méthode spécifique, et l'organisation structurelle vous aidera à naviguer dans ce qui se passe. Les «fantômes» vous permettent de convertir du code non linéaire complexe en un ensemble d'actions séquentielles, tandis que le «clonage» d'entités ne multiplie pas l'entropie, mais la réduit, car la répétition est remplacée par la liaison et aucun niveau d'abstraction supplémentaire n'est créé.
50 fichiers dispersés avec des fichiers source sont 50 fichiers dispersés. 50 nœuds avec des codes sources est une base de connaissances avec un désir interne d'auto-organisation.
Visualisez-le
Avant de se lancer dans le niveau de difficulté Nightmare, revenons à l'interface.
Les panneaux de l'éditeur peuvent être déplacés pour organiser au mieux votre espace de travail. Chaque fichier conserve ses propres paramètres d'apparence. Vous pouvez fermer tous les panneaux à l'exception de l'arborescence. Afin de renvoyer les panneaux, cliquez avec le bouton droit sur l'en-tête de l'arborescence.
Dans le même menu, il y a un certain rendu. Cette petite chose est conçue selon son nom pour afficher tout dans le monde.
Par défaut, le rendu tente de restituer le texte du nœud en tant que
reStructuredText . D'autres modes de fonctionnement sont inclus en forçant le type de contenu au nom du nœud.
Comme vous pouvez le voir dans le tableau, le rendu ne fonctionne pas très vigoureusement, la bonne nouvelle est que Leo Editor peut être étendu avec des plugins, y compris visuels. Par exemple, je devais charger les nombres dans des tableaux et dessiner des graphiques, tout en changeant les données initiales de mille fois.
Le code minimum du plugin visuel ressemble à ceci:
from leo.core.leoQt import QtCore, QtGui, QtWidgets import leo.core.leoGlobals as g class My_Plugin_Widget(QtWidgets.QWidget): def __init__(self, parent=None, leo_com=None): super(My_Plugin_Widget, self).__init__(parent) c = leo_com self.c = c self.layout = QtWidgets.QVBoxLayout() self.message = QtWidgets.QLabel("Hello there!", self) self.layout.addWidget(self.message) self.setLayout(self.layout) def init(): g.registerHandler("after-create-leo-frame", onCreate) g.plugin_signon(__name__) return True def onCreate(tag, keys): c = keys.get("c") if not c: return dw = c.frame.top dock = g.app.gui.create_dock_widget(closeable=True, moveable=True, height=150, name='My plugin') dw.leo_docks.append(dock) dock.setWidget(My_Plugin_Widget(leo_com=c)) dw.splitDockWidget(dw.body_dock, dock, QtCore.Qt.Horizontal) dock.show()
Le plugin est nécessaire:
- Enregistrer dans
%USERPROFILE%\Miniconda3\Lib\site-packages\leo\plugins\ - Inscrivez-vous dans le fichier myLeoSettings.leo dans le
@settings\@enabled-plugins
Vous pouvez lire ici comment créer des plugins, s'il est impatient d'obtenir plus d'informations, alors le seul moyen est d'étudier le plugin viewrendered.py vous-même.
Pourquoi tout cela? Encore une fois à des possibilités illimitées. Un accès complet à QT vous permet soit de reproduire des informations de manière arbitraire, soit de les saisir de la manière la plus inattendue.
Contenu et forme
Tout ce qui est décrit ci-dessus ressemble à un outil pratique pour résoudre une gamme limitée de tâches d'écran, pas plus. La conversion de l'arborescence en fichier externe est linéaire et limitée par des cadres stricts. Même les noms des nœuds jouent le rôle de commentaires, mais ne comportent pas d'autres fonctionnalités utiles. Mais en pratique, il s'avère qu'il est très approprié de décrire une entité complexe pour la pensée humaine avec un arbre, mais en même temps, le format de la machine peut ne pas ressembler à quoi que ce soit et / ou ne pas avoir de structure distincte du tout. Pour un exemple simple, prenez HTML. Il serait très pratique et facile (jugement de valeur) de préparer le balisage sous cette forme:
Tout est structurellement cohérent et visuel, il est impossible de se tromper en ne fermant pas ou en plaçant incorrectement une étiquette, et faire des changements de n'importe quelle échelle est élémentaire. Bien que le fichier de sortie HTML soit «linéairement proportionnel» à cette structure fictive, le mécanisme d'attachement de section n'est pas capable de produire ce qui suit:
- Balises d'ouverture-fermeture
- Attribuer le texte du nœud comme attributs de balise
- Le texte des nœuds avec le nom spécial "> <" est placé à l'intérieur de la balise correspondante
Eh bien, bien sûr, Leo Editor donne un accès illimité à l'arbre à partir du code du nœud. A la fois pour la lecture et l'écriture. Ce qui permet d'effectuer des modifications arbitraires des représentations de l'information pour l'homme et la machine. Dans toutes les directions et autant de fois que vous le souhaitez. Vous pouvez télécharger un certain format, le reconstruire dans une arborescence compréhensible pour VOUS, apporter des modifications et le reconvertir. Si le format de sortie est trivial, vous pouvez écrire un fichier externe en utilisant Python. Si le format est complexe et / ou qu'une quantité importante de données est présente, alors il est avantageux de passer du temps à déplacer des données vers un nœud de fichier avec des sections, car cela facilite grandement le débogage des conversions.Description des fonctions pour travailler avec un arbre:D'autres fonctions peuvent être choisies à partir des sources de Leo Editor et des fichiers .leo complets, et il n'y a vraiment aucune documentation ( sauf pour cette page ) = (À propos, cet article est écrit dans Leo Editor.
Le code suivant est utilisé pour exporter l'arborescence au format HTML: @language python from pathlib import Path @others path = Path('C:\\Projects\\article\\') / 'out.html' out_text = '<body><script>document.body.style.fontSize = 20;</script>' n = g.findNodeAnywhere(c, 'TITLE') assert nh == ('TITLE') tag = f'<h1>{nb}</h1> ' out_text = out_text + tag + '\n\n' n = g.findNodeAnywhere(c, 'TEXT') assert nh == ('TEXT') for header_node in n.children(): anchor_id = hash(header_node.h) tag = f'<anchor>{anchor_id}</anchor><h3>{header_node.h}</h3>' out_text = out_text + tag + '\n' if '' == header_node.h: text = make_toc(header_node) tag = f'{text}' out_text = out_text + tag + '\n' for content_node in header_node.children(): if '@image' in content_node.h: tag = f' <img src="{content_node.b}" alt=" "> ' else: text = content_node.b if not 'table' in content_node.h: content_node.h = ' '.join(content_node.b.split()[:3]) text = text.replace('\n', ' ') tag = f'{text}' out_text = out_text + tag + '\n' tag = ' <hr/>' out_text = out_text + tag + '\n' out_text = out_text + '</body>' + '\n' with open(path, 'w', encoding='utf-8') as f: f.write(out_text) g.es('.')
Je vais me construire un IDE
Pas un seul python, alors essayons de nous équiper d'un coin sous ... n'importe quoi. Tout d'abord, appuyez enfin sur le bouton du bouton de script.
Cette action entraîne l'apparition d'un nouveau bouton sous le menu principal avec le nom du nœud actuel. La logique suggère que cliquer sur ce bouton nouvellement créé entraînera une tentative d'exécution de code à partir du nœud associé au bouton. Il est pratique, mais peu pratique, que le bouton s'évapore après avoir redémarré l'éditeur. Pour garder le bouton toujours à sa place, vous devez ajouter un sort spécial au nom du nœud @buttonet redémarrer Leo Editor.
Pour chaque bouton utilisateur, vous pouvez attribuer un raccourci clavier à l'aide de l'expression. @key=
Pour exécuter un autre script à partir d'un script, vous devez appeler la fonctionc.executeMinibufferCommand('FIRE'). Chaque script avec un bouton lié tombe dans le pool général des commandes de l'éditeur sous le nom du bouton, c'est-à-dire que oui, votre script peut également être exécuté à partir de la ligne de commande de l'éditeur.
Afin d'exécuter le script du nœud actuellement en focus, à partir d'un autre script (comme si en appuyant sur [Ctrl] + [b]), la commande est utilisée c.executeMinibufferCommand('execute-script').Supposons que nous ayons préparé du code. Il serait avantageux de l'exécuter à partir de Leo Editor, et ce serait merveilleux d'obtenir toutes les erreurs de la console. Jetez un œil à un exemple de mise en forme automatique de code Python à l'intérieur d'un nœud à l'aide du célèbre utilitaire Black. @language python import subprocess import re c.frame.log.selectTab('Log') c.frame.log.clearLog() python_src = [] for line in pbsplitlines(): if re.match(r'@', line) is not None: line = line.replace('@', '# special_comment@') elif re.match(r'<<', line) is not None: line = line.replace('<<', '# special_comment<<') python_src.append(line) text = '\n'.join(python_src) proc = subprocess.Popen( ['black', '-', '-q', '--skip-string-normalization'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE, bufsize=0, shell=True, ) proc.stdin.write(text.encode()) proc.stdin.close() s = proc.stdout.read() if s: text = s.decode('utf-8') text = text.replace('# special_comment<<', '<<') text = text.replace('# special_comment@', '@') if 'error: cannot format -: Cannot parse:' in text: z = re.search(r'Cannot parse:.*', text) g.error(z.group(0)) else: undoData = c.undoer.beforeChangeNodeContents(p) pb = text.strip() c.undoer.afterChangeNodeContents(p,'Format with black', undoData) c.executeMinibufferCommand('execute-script')
Ce qui suit est fait:- Nous prenons le texte du nœud
- Nous mettons des instructions spéciales de l'éditeur Leo dans les commentaires
- Lancez l'utilitaire de console
- Nous passons le texte à l'utilitaire
- Lire sa conclusion
- Nous revenons à l'endroit instructions spéciales
- S'il n'y a pas d'erreurs, remplacez le texte actuel par formaté
- Exécutez le code du nœud
Cet échantillon sera tout à fait suffisant pour lancer quoi que ce soit sur sa base.Voyons maintenant une version belle et claire de l'utilisation pratique de Leo Editor. L'écosystème Python propose plusieurs solutions pour créer des applications GUI, dont l'une est le framework Kivy. Une caractéristique importante de ce cadre est la possibilité de charger une description d'interface dans une langue spéciale à partir d'un fichier texte. Leo Editor nous aidera, d'une part, à stocker le code et la description de l'interface dans un seul espace, et d'autre part, il remplacera l'édition de texte par l'édition d'arbre, ce qui nous rapprochera en quelque sorte des croquis de l'interface wysiwyg.
Quels faits peuvent être extraits de la capture d'écran ci-dessus:- Leo Editor Kivy
- RUN make_GUI, make_py,
Ci-dessus, vous pouvez voir à quoi ressemble la description de l'interface sous forme assemblée. Cela peut être aromatisant, mais la ferme collective de gauche semble être une solution plus gérable et industrielle. La bonne version demande d'y faire des fautes de frappe vendredi soir.Nous passons à la succursale avec le code.
Très propre. Et c'est clair. Nous ne prêtons pas attention à DATAGRAPH. Et les cours?
Le cercle s'est fermé, puis ce qui s'est passé cette histoire est venu sous la forme d'une implémentation de fortune du navigateur de classe pour Python. Les en-têtes de nœuds ne sont pas uniquement des commentaires, leur contenu est utilisé lors de la génération de fichiers .py. Les niveaux d'imbrication de classe forment automatiquement une hiérarchie d'héritage. Tout ce que nous adorons.
KA-EE-FF !!! Ne vous concentrez pas sur la signification de ce qui se passe, les cours sont lancés pour une capture d'écran.Quelque chose de similaire peut être fait sur la simple fonctionnalité des sections de fichier, mais vous devrez spécifier explicitement toutes les constructions de langage (def, class ...), et avec toutes les modifications, vous devrez vous rappeler d'y apporter de nombreuses corrections (et les en-têtes suspendus inutiles des nœuds aussi )Et encore une fois, sur un seul espace de code et d'interface. Tout d'abord, souvenez-vous de la recherche de navigation, qui vous permet de rechercher rapidement des gestionnaires de code pour les éléments visuels et les éléments visuels du code.
Deuxièmement, il existe toujours une fonctionnalité aussi attendue qu'un éditeur de texte supplémentaire.
Hop!
Il n'est donc pas nécessaire de faire des allers-retours avec une édition mutuelle complexe des nœuds.Au fait:
Liberté de pensée
En fin de compte, il y aura un peu contre nature. Tout ce qui est décrit ci-dessous ne doit pas être considéré comme une démonstration de bonnes pratiques d'ingénierie, c'est juste une graine pour cristalliser vos idées personnelles.Le point de départ de la première expérience: si la plupart des programmes sont impliqués à plusieurs reprises dans la production d'autres tableaux de données à partir d'un seul tableau de données, alors pourquoi ne pas créer un bloc de construction simple décrit par une classe universelle avec une interface de réception / sortie de données unifiée afin de reliez visuellement des blocs similaires dans l'arborescence Leo Editor, à l'image de la programmation sur des graphiques (blocs fonctionnels). À la différence qu'il s'agira d'un système hybride de classes de blocs, et chaque façon de décrire le code sera utilisée en fonction de l'avantage maximal à long terme.Une unité fonctionnelle élémentaire doit: avoir une entrée pour recevoir des informations, être en mesure de répondre à son type, traiter les informations initiales, regrouper les résultats du traitement dans un format de transmission et traduire le résultat.
Supposons qu'il y ait une tâche audacieuse d'analyser les sites. Nous aurons besoin des blocs suivants:- Composant réseau
- Analyseur de page Web
- Bloc pour la communication des données reçues et interface graphique
La mise en œuvre pratique minimale d'un bloc suffisamment universel, qui tient dans la branche de classe, est indiquée ci-dessous.
Bien sûr, chaque bloc de béton peut recharger les méthodes typiques avec ses propres si deux règles sont strictement respectées:- Dans chaque bloc, la méthode de décodage appelle nécessairement le processus, qui à son tour appelle les codes
- La méthode d'encodage appelle la méthode de décodage sur tous les blocs enregistrés comme sorties.
C'est-à-dire: la disponibilité de l'unification structurelle et l'homogénéité de l'échange d'informations sont garanties.
La même chose, mais plus clairement:- Le produit d'origine se trouve dans la plaque de gauche.
- Decode prépare le produit pour le traitement
- Après cela, le bloc remplit sa fonction principale dans la méthode de processus
- Le produit est conditionné par encodage
- Le produit emballé est transféré aux unités suivantes
Chaque bloc se révèle être assez indépendant, la seule chose qu'il doit savoir sur le monde extérieur est une manière spécifique d'analyser les données entrantes. Le code universel est responsable de l'implémentation spécifique de la connexion des blocs entre eux. Par conséquent, si nous avons plusieurs pipelines similaires disponibles, vous pouvez simplement les copier dans leur ensemble, uniquement en apportant des modifications à des implémentations spécifiques des méthodes de processus.Dans l'image suivante, vous pouvez observer quelque chose de très similaire au travail avec les classes décrit dans la section précédente. La différence est que l'imbrication des nœuds n'établit pas la relation parent-enfant, mais la relation entrée-sortie des blocs correspondants. Pour organiser l'échange de données avec des blocs non adjacents, une béquille est utilisée sous la forme d'une annonce explicite des sorties, ce qui est justifié par le petit nombre de ces cas.
Avec cette approche, le nombre de pipelines devient indifférent: deux ou 50. Le nombre d'étapes de traitement de l'information est également insignifiant (dans des limites raisonnables), cela n'affecte pas la simplicité de la compréhension, contrairement au gonflement des modules de texte. Lors de la copie de convoyeurs en une seule étape, une toute nouvelle chaîne se forme. Tout est organisé de façon absolument identique, il est facile de faire des changements même après 5 ans, le principe méthodologique d'organisation des fonctionnalités est le même, il n'est pas nécessaire de créer des châteaux éthérés dans la tête à partir des abstractions.
La connexion de pipelines personnalisés ne déforme pas l'image globale, car la logique de travail avec des données arbitraires est invariablement identique.
La deuxième histoire absurde. J'avais besoin de faire un jeu Kvent (un analogue direct d'un jeu bien connu à l'intérieur d'un jeu encore plus connu, pour le jeu dans lequel des cartes à jouer standard sont utilisées). Il existe de nombreuses approches différentes de l'organisation du cycle de jeu, l'une des options naïves est la machine à états. Avec la machine à états, tout va bien et simple en théorie, en pratique, prendre en charge plus de 7 états dans n'importe quel programme réel devient progressivement ennuyeux sans ajouter quelques couches d'abstractions. À ce stade, je pensais que la maintenance visuelle de la machine d'état sous la forme d'un arbre est une option intéressante.
Nous écrivons un générateur de code de programme à partir d'un arbre, il produit le résultat suivant:
Il n'y a pas de peur.
Vient ensuite un changement de condition par condition. Cela se fait de façon suspecte.
C'était juste une affaire de cartes avec le remplacement d'une paire de cartes arbitraires. Ok, partagez une seule machine en plusieurs machines.
Ensuite, la logique de traitement du tour de jeu est née.
À ce stade, la limite d'applicabilité pratique d'une telle description de la machine d'état est brisée, bien que l'arbre ne semble effrayant que s'il est intentionnellement déployé à cent pour cent. Mais il y avait toujours des effets complètement non réalisés de l'influence des cartes avec des images sur le cours du jeu. On peut supposer qu'une machine événementielle pour une telle tâche serait une meilleure solution. Et encore une fois, il est facile de le faire sur les arbres;)
Hourra, la fin
L'éditeur Leo manque cruellement d'auto-complétion normale et de surbrillance multiple du mot sélectionné («surlignage intelligent» dans le bloc-notes ++). Mais même avec ces défauts gras, il est facile de le supporter, car une fois que vous l'avez essayé, il est déjà impossible de se passer de cet outil pratique dans lequel vous pouvez peindre sans effort votre environnement personnel pour n'importe quelle tâche. Y a-t-il quelque chose de similaire ou de meilleur dans le monde? Il y a beaucoup de monstres parmi l'IDE, ils sont extrêmement bourrés de fonctionnalités intelligentes intelligentes, mais lesquelles offrent un pouvoir similaire sur les informations et lesquelles offrent autant de liberté dans l'organisation du flux de travail?Idée, matériel, outil, produit. Dans le monde de l'ingénierie, un outil de génération précédente vous permet de passer à la prochaine génération d'outils plus sophistiqués. Nous sommes passés d'une perceuse à main à des appareils de culture mettant en vedette des chats utilisant l'électricité. La programmation était suspendue au stade des bons tours, mais au lieu d'aller plus loin, nous soutenons quel alliage est le meilleur du coupeur, et vous devez alimenter par le dessus ou par le côté. Leo Editor n'est pas la réponse aux questions de demain, c'est un signal de ce qui peut être mieux fait.Le fait n'est pas qu'un programmeur peut résoudre le problème en écrivant du code, tandis que l'autre «pousse» la même chose (conditionnellement). Un outil dans lequel vous pouvez «cliquer» (conditionnellement) vous permettra de résoudre des problèmes auparavant inaccessibles en termes de temps et de complexité. À l'avenir, nous aurons besoin de programmes qui écrivent en temps réel des millions de programmes connexes, et nous n'avons rien pour gérer la complexité de cette échelle.En général, créez votre réalité, et s'il n'y a pas d'outils nécessaires pour cela, faites-les, cela fonctionne.
UPD Exemples d'application
Admin : bibliothèque de commandes. Vous pouvez simplement le stocker, vous pouvez l'exécuter tel quel, vous pouvez utiliser les paramètres d'argument à l'intérieur de l'arborescence. Par exemple, organisez le travail avec plusieurs bases de données.
Synthèse algorithmique de la musique : organisation de la piste
Embedder : organisation arbitraire du code dans le cas où votre environnement est limité en moyens.Il y a deux options:1. Diviser le programme en sections dans l'ordre le plus favorable2. Si le langage n'a pas de fonctions, alors elles peuvent être simulées à l'aide de fantômes.
Il y a trois façons d'organiser l'ordre d'exécution du code:
Pentester : transférez votre arsenal habituel vers votre "frappe de Cobalt personnelle" "