La ligne de commande interactive¶

Dans la plus grande partie de ce tutoriel, nous supposons que vous avez lancé l’interpréteur Sage avec la commande sage. Cela démarre une version adaptée du shell (interpréteur de commandes) IPython et importe un grand nombre de fonctions et de classes qui sont ainsi prêtes à l’emploi depuis l’invite de commande. D’autres personnalisations sont possibles en éditant le fichier $SAGE_ROOT/ipythonrc. Au démarrage, le shell Sage affiche un message de ce genre :

┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 9.7, Release Date: 2022-01-10                     │
│ Using Python 3.10.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘


sage:

Pour quitter Sage, tapez Ctrl-D ou tapez quit ou exit.

Sage

sage: quit
Exiting Sage (CPU time 0m0.00s, Wall time 0m0.89s)

Python

>>> from sage.all import *
>>> quit
Exiting Sage (CPU time 0m0.00s, Wall time 0m0.89s)

L’indication wall time donne le temps écoulé à votre montre (ou l’horloge suspendue au mur) pendant l’exécution. C’est une donnée pertinente car le temps processeur (CPU time) ne tient pas compte du temps utilisé par les sous-processus comme GAP et Singular.

(Il vaut mieux éviter de tuer un processus Sage depuis un terminal avec kill -9, car il est possible que Sage ne tue pas ses processus enfants, par exemple des processus Maple qu’il aurait lancés, ou encore qu’il ne nettoie pas les fichiers temporaires de $HOME/.sage/tmp.)

Journal des entrées-sorties¶

Enregistrer le journal d’une session Sage n’est pas la même chose que sauvegarder la session (voir Enregister et recharger des sessions entières pour cette possibilité). Pour tenir un journal des entrées (et optionnellement des sorties) de Sage, utilisez la commande logstart. Tapez logsatart? pour plus d’informations. Cette commande permet d’enregistrer toutes les entrées que vous tapez, toutes les sorties, et de rejouer ces entrées dans une session future (en rechargeant le fichier journal).

was@form:~$ sage
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 9.7, Release Date: 2022-01-10                     │
│ Using Python 3.10.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘

sage: logstart setup
Activating auto-logging. Current session state plus future input saved.
Filename       : setup
Mode           : backup
Output logging : False
Timestamping   : False
State          : active
sage: E = EllipticCurve([1,2,3,4,5]).minimal_model()
sage: F = QQ^3
sage: x,y = QQ['x,y'].gens()
sage: G = E.gens()
sage:
Exiting Sage (CPU time 0m0.61s, Wall time 0m50.39s).
was@form:~$ sage
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 9.7, Release Date: 2022-01-10                     │
│ Using Python 3.10.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘

sage: load("setup")
Loading log file <setup> one line at a time...
Finished replaying log file <setup>
sage: E
Elliptic Curve defined by y^2 + x*y  = x^3 - x^2 + 4*x + 3 over Rational
Field
sage: x*y
x*y
sage: G
[(2 : 3 : 1)]

Si vous utilisez le terminal Konsole de KDE, vous pouvez aussi sauver votre session comme suit : après avoir lancé Sage dans la konsole, ouvrez le menu « Configuration » et choisissez « Historique… » puis comme nombre de lignes « Illimité ». Ensuite, lorsque vous souhaitez enregistrer l’état de votre session, sélectionnez « Enregistrer l’historique sous… » dans le menu « Édition » et entrez le nom d’un fichier où enregistrer le texte de votre session. Une fois le fichier sauvegardé, vous pouvez par exemple l’ouvrir dans un éditeur comme xemacs et l’imprimer.

Coller du texte ignore les invites¶

Imaginons que vous lisiez une session Sage ou Python et que vous vouliez copier-coller les calculs dans Sage. Le problème est qu’il y a des invites >>> ou sage: en plus des entrées. En fait, vous pouvez tout à fait copier un exemple complet, invites comprises : par défaut, l’analyseur syntaxique de Sage supprime les >>> et sage: en début de ligne avant de passer la ligne à Python. Par exemple, les lignes suivantes sont interprétées correctement :

Sage

sage: 2^10
1024
sage: sage: sage: 2^10
1024
sage: >>> 2^10
1024

Python

>>> from sage.all import *
>>> Integer(2)**Integer(10)
1024
>>> sage: sage: Integer(2)**Integer(10)
1024
>>> >>> Integer(2)**Integer(10)
1024

Trucs et astuces IPython¶

Comme signalé plus haut, Sage utilise l’interpréteur de commandes IPython, et met donc à votre disposition toutes les commandes et fonctionnalités de celui-ci. Vous voudrez peut-être consulter la documentation complète de IPython. Voici en attendant quelques astuces utiles – qui reposent sur ce que IPython appelle des « commandes magiques » :

Lorsque l’on souhaite saisir un morceau de code complexe, on peut utiliser %edit (ou %ed, ou ed) pour ouvrir un éditeur de texte. Assurez-vous que la variable d’environnement EDITOR est réglée à votre éditeur favori au démarrage de Sage (en plaçant si nécessaire quelque chose du genre export EDITOR=/usr/bin/emacs ou encore export EDITOR=/usr/bin/vim dans un fichier de configuration convenable, par exemple .profile). La commande %edit à l’invite de Sage ouvrira l’éditeur sélectionné. Vous pouvez alors par exemple saisir une définition de fonction:
```
def some_function(n):
    return n**2 + 3*n + 2
```
puis enregistrer le fichier et quitter l’éditeur. La fonction some_function est désormais disponible dans votre session Sage, et vous pouvez la modifier en saisissant edit some_function à l’invite de commande.
Si vous souhaitez reprendre une version modifiée du résultat d’un calcul dans une nouvelle commande, tapez %rep après avoir fait le calcul. Cela récupère le texte du résultat et le place sur la ligne de commande, prêt à être modifié.
Sage
sage: f(x) = cos(x) sage: f(x).derivative(x) -sin(x)
Python
>>> from sage.all import * >>> __tmp__=var("x"); f = symbolic_expression(cos(x)).function(x) >>> f(x).derivative(x) -sin(x)
Ainsi, après les commandes ci-dessus, la commande %rep fournit un nouvel invite de commande pré-rempli avec le texte -sin(x) et le curseur en fin de ligne.

Pour plus d’information, entrez la commande %quickref pour un résumé des possibilités de IPython. Au moment où cette documentation est écrite (avril 2011), Sage emploie IPython 0.9.1. La documentation des commandes magiques est disponible en ligne, et divers aspects un peu plus avancés de leur fonctionnement sont décrits ici.

Erreurs et exceptions¶

Quand quelque chose ne marche pas, cela se manifeste habituellement par une « exception » Python. Python essaie de plus de donner une idée de ce qui a pu déclencher l’exception. Bien souvent, il affiche le nom de l’exception (par exemple NameError ou ValueError, voir le manuel de référence de la bibliothèque de Python [PyLR] pour une liste complète). Par exemple :

Sage

sage: 3_2
------------------------------------------------------------
   File "<console>", line 1
     ZZ(3)_2
           ^
SyntaxError: invalid ...

sage: EllipticCurve([0,infinity])
------------------------------------------------------------
Traceback (most recent call last):
...
TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational

Python

>>> from sage.all import *
>>> Integer(3_2)
------------------------------------------------------------
   File "<console>", line 1
     ZZ(3)_2
           ^
SyntaxError: invalid ...

>>> EllipticCurve([Integer(0),infinity])
------------------------------------------------------------
Traceback (most recent call last):
...
TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational

Le débogueur interactif est parfois utile pour comprendre ce qu’il s’est passé. Il s’active ou se désactive avec %pdb (et est désactivé par défaut). L’invite ipdb>> du débogueur apparaît si une exception a lieu alors que celui-ci est actif. Le débogueur permet d’afficher l’état de n’importe quelle variable locale et de monter ou descendre dans la pile d’exécution. Par exemple :

Sage

sage: %pdb
Automatic pdb calling has been turned ON
sage: EllipticCurve([1,infinity])
---------------------------------------------------------------------------
<class 'exceptions.TypeError'>             Traceback (most recent call last)
...

ipdb>

Python

>>> from sage.all import *
>>> %pdb
Automatic pdb calling has been turned ON
>>> EllipticCurve([Integer(1),infinity])
---------------------------------------------------------------------------
<class 'exceptions.TypeError'>             Traceback (most recent call last)
...

ipdb>

Pour obtenir une liste des commandes disponibles dans le débogueur, tapez ? à l’invite ipdb> :

ipdb> ?

Documented commands (type help <topic>):
========================================
EOF    break  commands   debug    h       l     pdef   quit    tbreak
a      bt     condition  disable  help    list  pdoc   r       u
alias  c      cont       down     ignore  n     pinfo  return  unalias
args   cl     continue   enable   j       next  pp     s       up
b      clear  d          exit     jump    p     q      step    w
whatis where

Miscellaneous help topics:
==========================
exec  pdb

Undocumented commands:
======================
retval  rv

Tapez Ctrl-D ou quit pour revenir à Sage.

Recherche en arrière et complétion de ligne de commande¶

Commençons par créer l’espace vectoriel de dimension trois $V=\QQ^3$ comme suit :

Sage

sage: V = VectorSpace(QQ,3)
sage: V
Vector space of dimension 3 over Rational Field

Python

>>> from sage.all import *
>>> V = VectorSpace(QQ,Integer(3))
>>> V
Vector space of dimension 3 over Rational Field

Nous pouvons aussi utiliser la variante plus concise :

Sage

sage: V = QQ^3

Python

>>> from sage.all import *
>>> V = QQ**Integer(3)

Tapez ensuite le début d’une commande, puis Ctrl-p (ou flèche vers le haut) pour passer en revue les lignes qui commencent par les mêmes lettres parmi celles que vous avez entrées jusque-là. Cela fonctionne même si vous avez quitté et relancé Sage entre-temps. Vous pouvez aussi rechercher une portion de commande en remontant dans l’historique avec Ctrl-r. Toutes ces fonctionnalités reposent sur la bibliothèque readline, qui existe pour la plupart des variantes de Linux.

La complétion de ligne de commande permet d’obtenir facilement la liste des fonctions membres de $V$ : tapez simplement V. puis appuyez sur la touche tabulation.

Sage

sage: V.[tab key]
V._VectorSpace_generic__base_field
...
V.ambient_space
V.base_field
V.base_ring
V.basis
V.coordinates
...
V.zero_vector

Python

>>> from sage.all import *
>>> V.[tab key]
V._VectorSpace_generic__base_field
...
V.ambient_space
V.base_field
V.base_ring
V.basis
V.coordinates
...
V.zero_vector

Si vous tapez les quelques premières lettres d’un nom de fonction avant d’appuyer sur tab, vous n’obtiendrez que les fonctions qui commencent par ces quelques lettres :

Sage

sage: V.i[tab key]
V.is_ambient  V.is_dense    V.is_full     V.is_sparse

Python

>>> from sage.all import *
>>> V.i[tab key]
V.is_ambient  V.is_dense    V.is_full     V.is_sparse

Si vous cherchez à savoir ce que fait une fonction, par exemple la fonction coordinates, V.coordinates? affiche un message d’aide et V.coordinates?? le code source de la fonction, comme expliqué dans la section suivante.

Enregister et recharger des sessions entières¶

Sage dispose de fonctions très souples de sauvegarde et relecture de sessions entières.

La commande save_session(nom_de_session) enregistre toutes les variables définies dans la session courante sous forme de dictionnaire dans le fichier nom_de_session.sobj. (Les éventuelles variables qui ne supportent pas la sauvegarde sont ignorées.) Le fichier .sobj obtenu peut être rechargé comme n’importe quel objet sauvegardé ; on obtient en le rechargeant un dictionnaire dont les clés sont les noms de variables et les valeurs les objets correspondants.

La commande reload_session(nom_de_session) charge toutes les variables sauvées dans nom_de_session. Cela n’efface pas les variables déjà définies dans la session courante : les deux sessions sont fusionnées.

Commençons par démarrer Sage et par définir quelques variables.

Sage

sage: E = EllipticCurve('11a')
sage: M = ModularSymbols(37)
sage: a = 389
sage: t = M.T(2003).matrix(); t.charpoly().factor()
 _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2

Python

>>> from sage.all import *
>>> E = EllipticCurve('11a')
>>> M = ModularSymbols(Integer(37))
>>> a = Integer(389)
>>> t = M.T(Integer(2003)).matrix(); t.charpoly().factor()
 _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2

Nous sauvons maintenant notre session, ce qui a pour effet d’enregistrer dans un même fichier toutes les variables ci-dessus. Nous pouvons constater que le fichier fait environ 3 ko.

Sage

sage: save_session('misc')
Saving a
Saving M
Saving t
Saving E
sage: quit
was@form:~/tmp$ ls -l misc.sobj
-rw-r--r--  1 was was 2979 2006-01-28 19:47 misc.sobj

Python

>>> from sage.all import *
>>> save_session('misc')
Saving a
Saving M
Saving t
Saving E
>>> quit
was@form:~/tmp$ ls -l misc.sobj
-rw-r--r--  1 was was 2979 2006-01-28 19:47 misc.sobj

Enfin, nous redémarrons Sage, nous définissons une nouvelle variable, et nous rechargeons la session précédente.

Sage

sage: b = 19
sage: load_session('misc')
Loading a
Loading M
Loading E
Loading t

Python

>>> from sage.all import *
>>> b = Integer(19)
>>> load_session('misc')
Loading a
Loading M
Loading E
Loading t

Toutes les variables sauvegardées sont à nouveau disponibles. En outre, la variable b n’a pas été écrasée.

Sage

sage: M
Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0
and dimension 5 over Rational Field
sage: E
Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational
Field
sage: b
19
sage: a
389

Python

>>> from sage.all import *
>>> M
Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0
and dimension 5 over Rational Field
>>> E
Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational
Field
>>> b
19
>>> a
389

La ligne de commande interactive¶

Votre session Sage¶

Journal des entrées-sorties¶

Coller du texte ignore les invites¶

Mesure du temps d’exécution d’une commande¶

Trucs et astuces IPython¶

Erreurs et exceptions¶

Recherche en arrière et complétion de ligne de commande¶

Aide en ligne¶

Enregistrer et charger des objets individuellement¶

Enregistrer un objet comme texte¶

Enregister et recharger des sessions entières¶