This document is for an old version of Python that is no longer supported. You should upgrade and read the Python documentation for the current stable release.

# 29.2. `codeop` — Compilation de code Python

Le module `codeop` fournit des outils permettant d’émuler une boucle de lecture-évaluation-affichage (en anglais read-eval-print-loop ou REPL), comme dans le module `code`. Par conséquent, ce module n’est pas destiné à être utilisé directement ; pour inclure un REPL dans un programme, il est préférable d’utiliser le module `code`.

Cette tâche se divise en deux parties :

1. Pouvoir affirmer qu’une ligne d’entrée est une instruction complète, ou achève une instruction : en bref, savoir s’il faut afficher «`>>>`» ou «`...`» à sa suite.

2. Conserver les instructions déjà entrées par l’utilisateur, afin que les entrées suivantes puissent êtres compilées avec elles.

Le module `codeop` fournit un moyen d’effectuer ces deux parties, individuellement ou simultanément.

Pour ne faire que la première partie :

`codeop.``compile_command`(source[, filename[, symbol]])

  Essaye de compiler source, qui doit être une chaîne de caractères représentant du code Python valide et renvoie un objet code le cas échéant. Dans ce cas, l’attribut de nom de fichier de l’objet code renvoyé sera filename (`'<input>'` par défaut). Renvoie `None` si source n’est pas du code Python valide, mais un début de code Python valide.

  En cas de problème avec source, une exception est levée ; `SyntaxError` si la syntaxe Python est incorrecte, et `OverflowError` ou `ValueError` si un littéral invalide est rencontré.

  L’argument symbol détermine si source est compilée comme une instruction (`'single'`, par défaut) ou comme une expression (`'eval'`). Toute autre valeur lèvera `ValueError`.

  Note

  Il est possible (quoique improbable) que l’analyseur s’arrête avant d’atteindre la fin du code source ; dans ce cas, les symboles venant après peuvent être ignorés au lieu de provoquer une erreur. Par exemple, une barre oblique inverse suivie de deux retours à la ligne peut être suivie par de la mémoire non-initialisée. Ceci sera corrigé quand l’interface de l’analyseur aura été améliorée.

class `codeop.``Compile`

  Les instances de cette classe ont des méthodes `__call__()` de signature identique à la fonction native `compile()`, à la différence près que si l’instance compile du code source contenant une instruction `__future__`, l’instance s’en « souviendra » et compilera tous les codes sources suivants avec cette instruction activée.

class `codeop.``CommandCompiler`

  Les instances de cette classe ont des méthodes `__call__()` de signature identique à la fonction `compile_command()`, à la différence près que si l’instance compile du code source contenant une instruction `__future__`, l’instance s’en « souviendra » et compilera tous les codes sources suivants avec cette instruction activée.

A note on version compatibility: the `Compile` and `CommandCompiler` are new in Python 2.2. If you want to enable the future-tracking features of 2.2 but also retain compatibility with 2.1 and earlier versions of Python you can either write

    try:
        from codeop import CommandCompiler
        compile_command = CommandCompiler()
        del CommandCompiler
    except ImportError:
        from codeop import compile_command

which is a low-impact change, but introduces possibly unwanted global state into your program, or you can write:

    try:
        from codeop import CommandCompiler
    except ImportError:
        def CommandCompiler():
            from codeop import compile_command
            return compile_command

and then call `CommandCompiler` every time you need a fresh compiler object.