********
Postface
********

Pourquoi Python ?
=================

Les avantages de Python
-----------------------

Le langage d'implémentation de la base de Sage est le langage Python (voir
[Py]_), même si le code qui doit s'exécuter rapidement est écrit
dans un langage compilé. Python présente plusieurs avantages :

-  L'**enregistrement d'objets** est très facile en Python. Il existe en
   Python un vaste support pour enregistrer (presque) n'importe quel
   objet dans des fichiers sur le disque ou dans une base de données.

-  Python fournit d'excellents outils pour la  **documentation** des
   fonctions et des packages du code source, ce qui comprend
   l'extraction automatique de documentation et le test
   automatique de tous les exemples. Ces tests automatiques sont
   exécutés régulièrement de façon automatique, ce qui garantit que
   les exemples donnés dans la documentation fonctionnent comme
   indiqué.

-  **Gestion de la mémoire :** Python possède désormais un gestionnaire
   de mémoire bien pensé et robuste ainsi qu'un ramasse-miettes (*garbage
   collector*) qui traite correctement les références circulaires et
   tient compte des variables locales dans les fichiers.

-  **Énormément de packages** d'ores et déjà disponibles pour Python
   pourraient se révéler d'un grand intérêt pour les utilisateurs de
   Sage : analyse numérique et algèbre linéaire, visualisation 2D et 3D,
   réseau (pour le calcul distribué, la mise en place de serveurs - par
   exemple twisted), bases de données, etc.

-  **Portabilité :** Python se compile sans difficulté et en quelques
   minutes sur la plupart des plates-formes.

-  **Gestion des exception :** Python possède un système sophistiqué et
   bien pensé de gestion des exceptions, grâce auquel les programmes
   peuvent rétablir leur fonctionnement normal même si des erreurs
   surviennent dans le code qu'ils appellent.

-  **Débogueur :** Python comprend un débogueur. Ainsi, quand un
   programme échoue pour une raison quelconque, l'utilisateur peut
   consulter la trace complète de la pile d'exécution, inspecter l'état de
   toutes les variables pertinentes et se déplacer dans la pile.

-  **Profileur :** Il existe un profileur Python, qui exécute le code et
   renvoie un rapport qui détaille combien de fois et pendant combien de
   temps chaque fonction a été appelée.

-  **Un langage :** Au lieu d'écrire un **nouveau langage** pour les
   mathématiques comme cela a été fait pour Magma, Maple, Mathematica,
   Matlab, GP/PARI, GAP, Macaulay 2, Simath, etc., nous utilisons le
   langage Python, qui est un langage de programmation répandu,
   activement développé et optimisé par des centaines de développeurs
   qualifiés. Python, avec son processus de développement
   éprouvé, fait partie des success stories majeures de
   l'open source (see [PyDev]_).


.. _section-mathannoy:

Le préprocesseur Sage et les différences entre Sage et Python
-------------------------------------------------------------

Certains aspects mathématiques de Python peuvent induire des confusions.
Aussi, Sage se comporte différemment de Python à plusieurs égards.


-  **Notation de l'exponentiation :** ``**`` au lieu de ``^``. En Python,
   ``^`` désigne le "xor" (ou exclusif bit à bit) et non
   l'exponentiation. Ainsi en Python, on a

   ::

       >>> 2^8
       10
       >>> 3^2
       1
       >>> 3**2
       9

   Cette utilisation de ``^`` peut paraître étrange et surtout
   inefficace pour une utilisation purement mathématique puisque le ou
   exclusif n'est que rarement utilisé. Par commodité, Sage prétraite
   chaque ligne de commande avant de la transmettre
   à Python, en remplaçant par exemple les apparitions de ``^``
   (en dehors des chaînes de caractères) par des ``**``:

   ::

       sage: 2^8
       256
       sage: 3^2
       9
       sage: "3^2"
       '3^2'

    Le ou exclusif bit à bit est quant à lui noté ``^^``, et l'opération en
    place ``^^=`` fonctionne comme on s'y attend :

    ::

        sage: 3^^2
        1
        sage: a = 2
        sage: a ^^= 8
        sage: a
        10

-  **Division entière :** L'expression Python ``2/3`` ne se comporte pas
   de la manière à laquelle s'attendraient des mathématiciens. En Python 2, si
   ``m`` et ``n`` sont de type int, alors ``m/n`` est aussi de type int, c'est
   le quotient entier de ``m`` par ``n``. Par conséquent, ``2/3=0``. Ce
   comportement est différent en Python 3, où ``2/3`` renvoie un flottant
   ``0.6666...`` et c'est ``2//3`` qui renvoie ``0``.

   Dans l'interpréteur Sage, nous réglons cela en encapsulant
   automatiquement les entiers litéraux par ``Integer( )`` et en faisant
   de la division un constructeur pour les nombres rationnels. Par
   exemple :

   ::

       sage: 2/3
       2/3
       sage: (2/3).parent()
       Rational Field
       sage: 2//3
       0
       sage: int(2)/int(3)   # py2
       0

-  **Entiers longs :** Python possède nativement un support pour les entiers de
   précision arbitraire, en plus des int du langage C. Les entiers longs
   Python sont significativement plus lents que ceux que GMP fournit et
   sont marqués à l'affichage par un ``L`` qui les distingue des int (il
   est pas prévu de changer cela à court terme). Sage implémente les
   entiers en précision arbitraire en utilisant la bibliothèque C GMP.
   Les entiers longs GMP utilisés par Sage s'affichent sans le ``L``.

Plutôt que de modifier l'interpréteur Python (comme l'ont fait certaines
personnes pour leurs projets internes), nous utilisons le langage Python
exactement comme il est et rajoutons un pré-parseur pour IPython de sorte
que la ligne de commande de IPython se comporte comme l'attend un
mathématicien. Ceci signifie que tout code Python existant peut être
utilisé sous Sage. Toutefois, il faut toujours respecter les règles
standards de Python lorsque l'on écrit des packages à importer dans
Sage.

(Pour installer une bibliothèque Python, trouvée sur Internet par
exemple, suivez les instructions mais exécutez  ``sage -python`` au lieu
de ``python``.  La plupart du temps, ceci signifie concrètement qu'il
faut taper ``sage -python setup.py install``.)

Comment puis-je contribuer ?
============================

Si vous souhaitez contribuer au développement de Sage, votre aide sera grandement
appréciée ! Cela peut aller de contributions substantielles en code au
signalement de bogues en passant par l'enrichissement de la documentation.

Parcourez la page web de Sage pour y trouver les informations pour les
développeurs. Entre autres choses, vous trouverez une longue liste de
projets en lien avec Sage rangés par priorité et catégorie. Le Guide du
développeur Sage (`Sage Developer's Guide
<http://doc.sagemath.org/html/en/developer/>`_) contient également des
informations utiles. Vous pouvez aussi faire un tour sur le groupe
Google ``sage-devel``.

Comment citer Sage ?
====================

Si vous écrivez un article qui utilise Sage, merci d'y préciser les
calculs faits avec Sage en citant

::

    [SAGE], SAGE Mathematical Software, Version 4.3, http://www.sagemath.org

dans votre bibliographie (en remplaçant 4.3 par la version de Sage que
vous avez utilisée). De plus, pensez à rechercher les composants de Sage
que vous avez utilisés pour vos calculs, par exemple PARI, GAP, Singular,
Maxima et citez également ces systèmes. Si vous vous demandez quel
logiciel votre calcul utilise, n'hésitez pas à poser la question sur le
groupe Google ``sage-devel``. Voir :ref:`section-univariate` pour une
discussion plus approfondie de ce point.

------------

Si vous venez de lire d'une traite ce tutoriel et que vous avez une idée du temps qu'il vous a fallu pour le parcourir, merci de nous le faire savoir sur le groupe Google ``sage-devel``.

Amusez-vous bien avec Sage !
