Voir la source de Premiers pas avec Emacs et Python

Cette page est écrite pour permettre à des débutants avec l'éditeur de texte Emacs de bien démarrer, en utilisant le langage Python comme exemple. Une documentation similaire est disponible pour Atom : [[Premiers pas avec Atom et Python]]. Certaines options expliquées ici ont peut-être déjà été activées par défaut dans la configuration d'Emacs par défaut de l'Ensimag.

== Emacs ... un éditeur de texte ==

Emacs est un éditeur de texte, très puissant, extensible, même s'il n'est pas toujours très intuitif. Certains disent qu'il peut tout faire sauf le café, [https://www.emacswiki.org/emacs/CoffeeMode ils se trompent].

D'abord, qu'est-ce que ça veut dire, un « Éditeur de texte » ? Vous avez sûrement déjà utilisé un « ''Traitement'' de texte », qui permet de taper du texte, de le mettre en forme (gras, italique, taille et choix des polices, …). Un éditeur de texte édite du texte brut : pas de mise en forme, pas de dessins, juste du texte. Une suite de caractères, quoi. Mais en informatique, on trouve du texte brut partout : langage de programmation, fichiers de configuration de beaucoup de logiciels, …

On pourrait essayer d'éditer le texte d'un programme Python avec un traitement de texte classique, mais comme les fichiers créés par ces logiciels ne sont pas des fichiers textes bruts, nous aurions de sérieux problèmes au moment de l'exécution du programme Python.

=== Ouvrir un fichier ===

Vous devriez avoir un fichier <code>hello.py</code> dans le répertoire <code>stage-unix</code> sur votre compte. Si ce n'est pas le cas, commencez par télécharger le fichier [https://chamilo.grenoble-inp.fr/courses/ENSIMAG3MMUNIX//document/stage-unix/hello.py hello.py], et sauvegardez-le sur votre compte.

Un moyen simple d'ouvrir ce fichier dans Emacs est de lancer, en ligne de commande :

 emacs hello.py

Si vous voulez lancer emacs sans la configuration de l'Ensimag, il suffit de lancer plutôt

 emacs -q hello.py

Un autre moyen, c'est de lancer Emacs, puis dans le menu <code>File</code>, choisir <code>Open File…</code>, et choisir le fichier à ouvrir.

[[Image:Emacs-open-hello-py.png]]

Quand on a plusieurs fichiers sur lesquels on veut travailler en même temps, il ''faut'' ouvrir chaque fichier depuis une fenêtre Emacs déjà ouverte, sinon, on lance beaucoup de processus Emacs, c'est moins pratique, et ça consomme beaucoup plus de ressources de l'ordinateur.

En pratique, on va beaucoup plus vite en faisant la même chose au clavier, sans utiliser le menu. Depuis une fenêtre Emacs, faire <code>C-x C-f</code>, c'est à dire Control-x puis (sans relâcher la touche Control pour aller vite), Control-f. Une invite apparaît en bas de la fenêtre (ce qu'Emacs appelle le « minibuffer »). Entrez le nom du fichier (la touche tabulation permet de completer quand on a entré les premières lettres) et validez avec Entrée :

[[Image:Emacs-control-x-control-f.png]]

=== Créer un fichier ===

Quand on lance la commande <code>emacs</code> sans argument, une fenêtre s'ouvre, mais elle ne correspond à aucun fichier. Si on veut travailler sur un nouveau fichier, il faut créer ce fichier '''avant''' d'entrer son contenu (ce qui permet à Emacs de savoir à quel langage de programmation il doit s'adapter) :

 emacs

[[Image:Emacs-visit-new-file.png‎]]

En fait, tout ce que nous venons de voir pour ouvrir un fichier existant s'applique aussi pour créer un nouveau fichier : il suffit de demander à ouvrir un fichier qui n'existe pas, et Emacs le créera pour vous. Par exemple depuis la ligne de commande :

 emacs nouveau_fichier.py

(Attention, cette version ouvre une nouvelle instance d'Emacs, à éviter si vous avez déjà un Emacs lancé)

Le plus rapide si vous avez déjà un Emacs lancé : <code>C-x C-f</code> (comme ci-dessus), entrez le nom du fichier à créer puis validez avec Entree :

[[Image:Emacs-control-x-control-f-new.png]]

=== Naviguer entre les fichiers ouverts ===

Si vous avez suivi les explications ci-dessus, vous avez maintenant deux fichiers ouverts dans Emacs : <code>hello.py</code> et <code>nouveau_fichier.py</code>. Dans la terminologie Emacs, un fichier ouvert s'appelle un ''buffer'' (c'est la copie du contenu du fichier dans la mémoire). On peut passer de l'un à l'autre avec le menu « Buffers » :

[[Image:Emacs-buffers.png]]

Là aussi, on peut aller bien plus vite au clavier avec le raccourcis <code>C-x b</code> (Control-x, puis relâcher, puis touche b). Entrez le nom du buffer (ou laissez vide pour choisir le buffer suggéré par Emacs), puis validez avec Entrée :

[[Image:Emacs-control-x-b.png]]

== Emacs et le Python ==

Revenons à notre fichier <code>hello.py</code>. Vous avez maintenant une fenêtre Emacs ouverte, avec le contenu de ce fichier affiché.

=== Coloration syntaxique ===

Premier constat : les mots clés (def, print, …) sont en couleur. Ah, mais on avait pourtant dit qu'il n'y avait pas de mise en forme dans un fichier texte ?!? Et non, il n'y a pas de couleurs ''dans'' le fichier, mais Emacs nous l'affiche quand même avec des couleurs. Vérifiez si vous voulez en faisant « <code>less hello.py</code> » dans un terminal, il n'y a pas de couleur.

[[Image:Emacs-coloring-hello-py.png]]

=== Indentation ===

L'indentation (espaces en début de ligne) est cruciale en Python : c'est ce qui détermine où se trouve la fin d'un bloc de code. Sur notre exemple, la fonction <code>dire_bonjour</code> se termine à la fin du bloc indenté, elle contient les deux instructions <code>print</code>.

Emacs vous aide à indenter votre code correctement : un appui sur la touche tabulation (notée TAB dans la suite) vous permet de choisir entre plusieurs indentations pour la ligne courante. Essayez de placer votre curseur sur la ligne <code>print("Et bienvenue à l'Ensimag !")</code>, et appuyez sur la touche TAB plusieurs fois. Emacs vous propose une version où cette ligne est désindentée (donc à l'extérieur de la fonction) et la version d'origine.

[[Image:Emacs-python-indent.png]]

Pour indenter/désindenter plusieurs lignes, Emacs vous aide aussi. Essayez par exemple de répéter 3 fois le contenu de la fonction en ajoutant <code>for i in range(3):</code> autour du corps de la fonction :

* Ajoutez la ligne <code>for i in range(3):</code> en début de fonction
* Sélectionnez les deux instructions <code>print</code> (à la souris)
* Appuyez sur Control-C, relâchez, puis appuyez sur la touche > : les deux lignes sont décalées. On aurait pu le faire pour un morceau de code plus long en utilisant autant de touches.

[[Image:Emacs-python-shift-region.png]]

On peut faire l'opération inverse avec Control-C puis < pour désindenter un morceau de code.

=== Exécution d'un programme Python ===

Emacs permet d'exécuter un programme Python sans quitter son éditeur, mais restons simple pour le moment : ouvrez un terminal et si besoin placez-vous (<code>cd</code>) dans le même répertoire que le fichier <code>hello.py</code>.

On peut exécuter le programme en entrant la commande <code>python3 hello.py</code> (attention, le 3 dans « python3 » est important) dans le terminal :

[[Image:Emacs-term-python.png]]

Une autre possibilité est de spécifier à l'intérieur du fichier qu'il s'agit d'un programme Python 3 en ajoutant en première ligne de <code>hello.py</code> :

 #! /usr/bin/env python3

Il faut maintenant rendre le fichier exécutable en exécutant cette commande dans un terminal :

 chmod +x hello.py

On peut maintenant exécuter le programme avec <code>./hello.py</code> :

[[Image:Emacs-term-chmod+x.png]]

=== Vérifications à la volée ===

Un défaut potentiel du langage Python est que la plupart des erreurs de programmation ne sont levées que pendant l'exécution du programme. Pour gagner du temps et écrire du code le plus fiable possible, il existe cependant des outils qui permettent de trouver certaines erreurs avant d'exécuter, et éventuellement en cours de frappe.

=== Utilisation de Flycheck et Flake8 ===

Nous allons commencer avec l'outil <code>flake8</code>, qui trouve à la fois de problèmes de formatage de code et des bugs potentiels comme des utilisations de variables ou fonctions indéfinis.

Essayons dans un premier temps depuis un terminal : lancez la commande

 flake8 hello.py

En principe, la commande ne doit produire aucune sortie : <code>flake8</code> n'a trouvé aucun problème avec notre programme. Modifiez maintenant le programme en remplaçant la définition de la fonction par <code>def dire_bonjour(arg)</code> (remplacer « nom » par « arg ») et recommencez. Vous devriez obtenir un avertissement :

[[Image:Emacs-term-flake8.png]]

En effet, nous utilisons la variable <code>nom</code> qui est maintenant indéfinie : c'est un bug. Le « F821 » n'est pas important : c'est le numéro de l'erreur.

Emacs peut nous faciliter la vie en appelant les outils comme <code>flake8</code> pour nous au fur et à mesure qu'on écrit le programme.

Dans la fenêtre Emacs, faites Alt-x (que l'on note <code>M-x</code> dans le jargon Emacs), puis entrez <code>flycheck-mode</code>, comme ceci :

[[Image:Emacs-M-x-flycheck-mode.png]]

Validez en appuyant sur « Entrée ». Emacs devrait vous répondre « flycheck mode enabled » :

[[Image:Emacs-flycheck-mode-enabled.png]]

Si ça ne marche pas, c'est que le mode flycheck n'est pas installé, [www.flycheck.org/ suivez les instructions sur le site de flycheck] pour l'installer (ce n'est pas nécessaire sur les machines de l'école).

La variable <code>nom</code> est maintenant soulignée en rouge. En passant la souris ou en passant le curseur sur l'erreur, on voit apparaître le message précis (undefined name 'nom'). Il n'y a plus qu'à corriger (par exemple en revenant au programme d'origine en changeant « arg » par « nom » dans la déclaration de la fonction).

Pour voir d'un coup d'œil s'il reste des erreurs, la barre en bas (appelée « modeline » dans Emacs) affiche <code>FlyC</code> quand tout va bien, et <code>FlyC:N/M</code> pour dire qu'il reste N erreurs et M avertissements.

=== Utilisation de Pylint ===

Flake8 est content de notre petit programme, mais nous sommes plus exigeants que cela. Nous allons maintenant dire à Emacs d'utiliser l'outil Pylint, bien plus pointilleux que flake8.

Ouvrez le fichier <code>.emacs</code>, et faites en sorte qu'il contienne ces lignes :

<source lang="lisp">
;; Nécessaire pour pouvoir configurer les packages additionnels
(require 'package)
(package-initialize)

;; Vérifications en cours de frappe
(when (functionp 'global-flycheck-mode)
  (global-flycheck-mode 1)
  (push 'python-pylint flycheck-checkers)
  )
</source>

Dans le <code>.emacs</code> fourni, ces lignes sont déjà présentes pour vous aider.

<!-- , mais sont commentées (le point-virgule est le caractère de début de commentaire dans le langage de configuration d'Emacs), il vous suffit donc de supprimer les point-virgules en tête de ligne. -->

Rechargez le fichier en faisant <code>M-x eval-buffer RET</code> (Alt-x, puis relacher, puis entrer « eval-buffer », puis validez avec Entrée). On peut aussi fermer Emacs et le relancer.

Ces quelques lignes font deux choses :

* Activer le mode flycheck par défaut pour tous les fichiers.

* Utiliser pylint pour les fichiers Python

Revenez maintenant au fichier <code>hello.py</code> et si besoin faites une modification triviale (ajouter un espace puis le supprimer par exemple) pour relancer l'analyse par flycheck. C'est maintenant Pylint qui vous donne les avertissements, et il en trouve trois nouveaux :

[[Image:Emacs-flycheck-pylint.png]]

Nous pouvons corriger comme ceci :

<source lang="python">
"""Module Python pour tester Flycheck et Pylint."""

def dire_bonjour(nom):
    """Fonction qui dit bonjour à l'utilisateur."""
    for _ in range(3):
        print("Bonjour,", nom, "!")
        print("Et bienvenue à l'Ensimag !")

dire_bonjour("vous")
</source>

Les deux chaînes de caractères ajoutées sont des « docstrings », et permettent de documenter le module python (en haut du fichier) et la fonction (entre la ligne <code>def</code> et la première ligne de code de la fonction). Nous avons remplacé <code>i</code> par <code>_</code> qui est la convention Python pour dire « une variable qui n'est jamais utilisée ».
<!-- au cas où : [[Image:Emacs-flycheck.png]] -->

=== <div id="flycheck-list-errors">Lister les erreurs, naviguer entre les erreurs</div> ===

L'affichage des erreurs dans le texte est pratique pour les éviter/corriger en cours de frappe, mais sous-optimal quand il s'agit de corriger plusieurs erreurs dans un fichier assez long (ce qui arrive souvent dans la vraie vie, mais aussi dans certaines étapes du jeu de piste ...). Une autre option est d'afficher la liste des erreurs. Dans une fenêtre Emacs, faites <code>C-c ! l</code> (c'est à dire : Control-c, puis ! puis la lettre l), ou bien <code>M-x flycheck-list-errors RET</code> (c'est à dire Alt-x, puis flycheck-list-errors, puis validation avec la touche Entrée. La touche tabulation permet de compléter, donc « flycheck-l » puis un appui sur tabulation suffit). Vous devriez obtenir ceci :

[[Image:Emacs-flycheck-list-errors.png]]

Vous pouvez maintenant cliquer sur une erreur pour placer le curseur au bon endroit.

Avec ou sans l'affichage de la liste, on peut aussi passer d'une erreur à l'autre avec <code>C-c ! n</code> (erreur suivante, 'n' comme 'next') et <code>C-c ! p</code> (erreur précédente, 'p' comme 'previous').

Plus d'informations sur [http://www.flycheck.org/en/latest/user/error-list.html cette page].

== Quelques généralités sur Emacs ==

=== Rechercher une chaine ===

La recherche de chaine dans Emacs est un peu différente de ce dont vous avez sans doute l'habitude, mais très pratique :

* C-s (control-s): Emacs n'ouvre pas de nouvelle fenêtre, mais demande la chaine à rechercher dans le « minibuffer » (en bas de la fenêtre)
* On commence à entrer la chaine, Emacs cherche au fur et à mesure qu'on tape.
* Pour aller à l'occurence suivante, C-s à nouveau.

[[Image:Emacs-python-Control-s.png]]

=== Exploration du menu Options ===

Les fonctionnalités les plus courantes d'Emacs sont disponibles dans le menu. Regardons le menu <code>Options</code>.

Par exemple, sélectionnez <code>Paren Match Highlighting</code>. Cette option active la correspondance visuelle des parenthèses. Essayez de taper, par exemple, « <code>print(2 + (3 - (4 + 5)))</code> ». Quand le curseur est sur une parenthèse ouvrante, ou derrière une parenthèse fermante, la parenthèse correspondante se met en couleur.

[[Image:Emacs-python-parent-match.png]]

Il y en a d'autres. On peux noter en particulier :

* « <code>C-x/C-c/C-v Cut and Paste</code> » (raccourcis claviers usuels sous Windows/Mac OS pour le copier/coller) pour être moins dépaysés.

* <code>Show/Hide → Speedbar</code>, pour naviguer dans vos fichiers et vos fonctions.

* <code>Options → Customize Emacs → Specific Option → “inhibit-splash-screen”</code> : <code>toggle</code> pour mettre a on, puis <code>State → Save for future sessions</code> : Désactiver l'écran d'accueil.

Notez que les options ne s'appliquent qu'au processus Emacs courant. Pour les sauvegarder pour la prochaine fois, faites <code>Save options</code> dans le même menu.

=== Le fichier .emacs ===

Nous allons maintenant aller un peu plus loin dans la configuration d'Emacs. Ouvrez le fichier <code>.emacs</code> (il peut s'appeler au choix <code>.emacs</code> ou <code>.emacs.el</code>, c'est comme on veut), à la racine de votre compte (menu <code>File</code>, <code>Open File</code>, ou bien <code>C-x C-f ~/.emacs RET</code>, c'est à dire Control-x, puis Control-f, le nom du fichier .emacs, puis Entrée).

Le début du fichier est votre configuration, telle qu'elle vous est proposée par l'équipe pédagogique. Nous avons changé le moins de choses possibles pour que vous ne soyez pas dépaysés si vous avez à utiliser Emacs sur d'autres machines, mais n'hésitez pas à jouer avec votre configuration.

À la fin du fichier, vous devriez trouver ce que « Save Options » a fait si vous avez suivi les instructions quelques lignes plus haut.

=== Raccourcis utiles ===

La refcard Emacs contient un tas de raccourcis utiles. Elle est disponible ici (<code>C-x</code> veut dire « Ctrl-x », <code>M-y</code> veut dire « Alt-y », <code>C-x h C-M-\</code> veut dire « Ctrl-x, puis relâcher, puis h, puis relâcher, puis Ctrl-Alt-backslash (donc, sur un clavier azerty, Ctrl-Alt-AltGr-8) » par exemple)
[https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf emacs-refcard.pdf]
<!-- la refcard24 pour centos7  [http://www-verimag.imag.fr/~moy/emacs/emacs23-refcard.pdf emacs23-refcard.pdf].-->

Avec de l'expérience, vous n'aurez plus besoin de votre souris, le clavier va beaucoup plus vite pour la plupart des tâches : en utilisation courante, on a les deux mains sur le clavier, les raccourcis clavier sont à une fraction de seconde de vos doigts …

Par ailleurs savoir utiliser son éditeur de texte entièrement au clavier est particulièrement utile, quand on se connecte avec ssh : En mode graphique (ssh -X), l'interface est souvent trop lente pour être utilisable, et quand on ne dispose pas de l'option graphique (-X ou -Y), comme avec [[Putty]], on ne dispose plus que des commandes du clavier.

=== Aller plus loin ===

Nous n'avons vu que le strict minimum pour commencer avec Emacs, mais apprendre ''vraiment'' à se servir de cet éditeur prend des années. Il est vivement conseillé de lire une documentation plus complète, comme l'une proposée dans [[Emacs|la page d'accueil]]. Vous allez passer énormément de temps devant votre éditeur de texte au cours de votre scolarité, vous gagnerez un temps énorme si vous êtes efficaces avec cet outil.

== Un peu d'aide pour le jeu de piste ==

Dans l'étape D3 du jeu de piste, on vous demande de faire '''rapidement''' plusieurs corrections sur un fichier pour le compiler. Voici quelques conseils pour aller vite.

=== Décommenter une portion de code ===

Pour décommenter une portion de code, on peut utiliser <code>M-x uncomment-region RET</code>, c'est à dire faire Alt-x (dans le jargon Emacs, <code>M</code> veut en général dire Alt), relacher, puis entrer uncomment-region (la complétion marche, vous pouvez écrire juste <code>unc</code> puis appuyer sur la touche tabulation), puis appuyer sur la touche Entrée.

Pour sélectionner tout le texte, on peut utiliser Menu « Edit » -> « Select all », mais le temps presse, on ira beaucoup plus vite au clavier : <code>C-x h</code> (c'est à dire Control-x, relacher, puis 'h').

En résumé : <code>C-x h M-x unc TAB RET</code> (10 touches).

(On aurait aussi pu utiliser les [http://www.gnu.org/software/emacs/manual/html_node/emacs/Rectangles.html opérations sur les rectangles] pour effacer les # en début de ligne) 

=== Rechercher-remplacer ===

Pour remplacer toutes les instances d'une chaine par une autre chaine, Emacs permet comme tout bon éditeur de texte de faire un rechercher/remplacer. On peut le trouver dans Menu « Edit » -> « Replace » -> « Replace string », mais là encore, le temps presse et nous irons beaucoup plus vite au clavier : <code>M-% [ RET ( RET</code> (sur un clavier azerty, vous aurez bien sûr besoin de la touche shift pour obtenir le %). Emacs positionne le curseur sur la première occurrence de texte à remplacer, l'utilisateur peut accepter (touche Espace), aller à l'occurrence suivante (touche 'n'), mais ce qui nous intéresse ici, c'est de tout remplacer d'un coup : touche '!'.

Emacs parcourt tout le texte de haut en bas, il faut donc démarrer d'en haut. Pour placer le curseur au début du texte, faites <code>M-<</code>.

En résumé : <code>M-< M-% [ RET ( RET ! M-< M-% ] RET ) RET !</code> (19 touches sur un clavier azerty, une petite dizaine de secondes)

=== Corriger les erreurs rapidement ===

Pour exécuter le programme dans un terminal, vous devriez avoir une commande comme

 python3 text_editor.py

dans l'historique de votre shell. Pour exécuter, il suffit donc de faire « flèche haut » (remonter dans l'historique), « Entrée » (2 touches).

En cas d'erreur à l'exécution, on peut utiliser la commande <code>M-g g</code> pour se positionner sur une ligne en particulier (''beaucoup'' plus rapide que de chercher la ligne à tâtons à la souris). Par exemple, si Python vous affiche :

<pre>
$ python3 toto.py
  File "toto.py", line 15
    if 0 = 0:
         ^
SyntaxError: invalid syntax
</pre>

Il suffira d'entrer <code>M-g g 15 RET</code> (6 touches, environ 3 secondes) pour vous placer ligne 15.

L'autre option, probablement la plus efficace, est bien sûr d'utiliser le mode flycheck pour passer d'une erreur à l'autre (cf. [[#flycheck-list-errors|ci-dessus]]).

=== Copier-coller rapide ===

Une fois le programme compilé et exécuté, on peut faire un copier-coller du résultat « à la Unix » : sélectionner le texte à la souris (c'est tout !), puis clic du milieu pour coller.

=== Si ça ne suffit pas ===

Si vous entrez la chaine « moretime » dans le champ qui attend la réponse, la page vous laissera plus de temps (le temps supplémentaire est mémorisé d'une fois sur l'autre). Si vous maitrisez bien les raccourcis claviers, vous ne devriez pas en avoir besoin.