# Tutoriel : votre premier fichier dans Turbo Python

À la fin de ce tutoriel, vous aurez compilé l'éditeur, écrit un petit programme Python dedans, vu les mots-clés changer de couleur à la frappe, enregistré le fichier et exécuté le résultat. Comptez une dizaine de minutes.

Aucune connaissance préalable de Turbo Python n'est nécessaire. Il vous faut Go 1.26 ou plus récent pour compiler l'éditeur, et [uv](https://docs.astral.sh/uv/) pour créer et lancer le projet Python.

## Prérequis

Vérifiez que Go est là — l'éditeur est écrit en Go, même si c'est un éditeur pour Python :

```bash
go version
```

Vous devriez voir quelque chose comme :

```
go version go1.26.5 linux/arm64
```

Si la commande échoue, installez d'abord Go : https://go.dev/dl/

Vérifiez qu'uv est là aussi :

```bash
uv --version
```

Vous devriez voir quelque chose comme :

```
uv 0.9.26
```

Si la commande échoue, installez d'abord uv : https://docs.astral.sh/uv/getting-started/installation/

## Étape 1 — Compiler l'éditeur

Depuis le dossier du projet, tapez :

```bash
make build
```

Vous devriez voir une ligne `go build`, puis une ligne qui nomme la version que le binaire annonce. Cette dernière ligne est une vérification, pas une décoration : elle exécute le binaire qui vient d'être lié et refuse une compilation dont l'estampille de version ne lui est jamais parvenue.

Nous avons maintenant un exécutable dans `bin/turbo-python`. Retenez où il est, pour pouvoir le lancer de n'importe où :

```bash
export TURBO="$PWD/bin/turbo-python"
```

## Étape 2 — Se faire un endroit où travailler

Turbo Python est à son meilleur à l'intérieur d'un projet, alors créons-en un :

```bash
cd /tmp && uv init hello && cd hello
```

Vous devriez voir :

```
Initialized project `hello` at `/tmp/hello`
```

`uv init` écrit un `pyproject.toml`, un `README.md`, un `.python-version` et un `main.py` contenant un hello-world. C'est `pyproject.toml` que Turbo Python cherche pour trouver la racine d'un projet, et c'est là que `pylsp` sera lancé. Nous allons remplacer le contenu de `main.py` par le nôtre.

## Étape 3 — Ouvrir l'éditeur

Lancez Turbo Python sur le fichier qu'uv a écrit :

```bash
$TURBO main.py
```

L'écran se remplit d'un bureau bleu. Vous devriez voir :

- une **barre de menus** en haut : `File  Edit  Search  Run  Code  Options  Window  Snippets  Python  Help`
- une **fenêtre** encadrée d'un double trait, intitulée `main.py`
- une **barre d'état** en bas : `F1 Describe  F2 Save  F3 Open …`

Le curseur clignote en ligne 1, colonne 1 — la barre d'état affiche `1:1` à droite.

À côté, la barre d'état dit l'une de deux choses. `LSP: ready` signifie que le serveur de langage a été trouvé et démarré. `LSP: no pylsp — pipx install "python-lsp-server[all]"` signifie qu'il ne l'a pas été, et nomme l'unique commande qui l'installe. Dans les deux cas la suite de ce tutoriel fonctionne ; le [guide de la complétion](../how-to/enable-completion.md) est là pour transformer le second message en premier.

Nous sommes dans l'éditeur.

## Étape 4 — Vider le fichier et taper un programme Python

Appuyez sur **Ctrl-A** pour tout sélectionner, puis sur **Suppr** pour effacer. La fenêtre est vide et son titre indique `main.py *` — l'étoile signale des modifications non enregistrées.

Tapez cette ligne, puis **Entrée** :

```python
def greet(name):
```

Regardez les couleurs pendant que vous tapez. `def` passe en **blanc gras** dès que le mot se termine : c'est un mot-clé. `greet` passe en **jaune gras** dès que vous tapez la `(` qui suit, parce que c'est ce qui en fait une fonction. `name` reste en **jaune** simple : c'est un identifiant ordinaire.

(Ce sont les couleurs de Turbo Classic, celles avec lesquelles l'éditeur démarre. L'étape 8 en change.)

Tapez maintenant quatre espaces vous-même, puis la ligne suivante :

```python
    message = f"Hello from {name}!"
```

**Entrée recopie l'indentation de la ligne courante ; elle n'ajoute pas de niveau après un deux-points.** Les blocs de Python sont faits d'indentation, et l'éditeur ne cherche pas à deviner où un nouveau bloc commence — les quatre espaces sont donc à taper une fois, et toutes les lignes suivantes les gardent gratuitement.

`f"Hello from {name}!"` passe en **vert**, en entier, `{name}` compris. C'est une seule chaîne : ce qui est entre les accolades est du Python, mais ce n'est pas coloré comme du Python, parce que décider où une expression s'arrête à l'intérieur d'un littéral demande un analyseur syntaxique et qu'ici il n'y a qu'un scanner. Ce compromis est écrit noir sur blanc dans [Coloration et complétion](../explanation/colouring-and-completion.md).

Appuyez sur **Entrée** — le curseur se pose sous le `m`, déjà indenté — et tapez :

```python
    print(message)
```

`print` passe en **cyan gras** : c'est l'une des primitives que le langage fournit, et non un nom venu de votre code.

Appuyez sur **Entrée**, puis sur **Maj-Tab** pour reprendre l'indentation, et tapez la dernière ligne :

```python
greet("Turbo Python")
```

Nous venons d'écrire un programme Python complet, coloré par l'éditeur au fil de la frappe.

Si la barre d'état affichait `LSP: ready` tout à l'heure, regardez le bord gauche de la dernière ligne : il y a un `!` dans la gouttière. Le serveur de langage a un avis sur notre fichier, et **Code ▸ Problems…** dit lequel — `warning  main.py:4  E305 expected 2 blank lines after class or function definition`. C'est une règle de style et non une erreur, et la laisser ne coûte rien ; ce qui compte est que la marque et le message soient là, et qu'ils arrivent sans que personne ne les demande.

## Étape 5 — Enregistrer

Appuyez sur **F2**.

L'étoile disparaît du titre, et la barre d'état affiche, un instant :

```
Saved main.py
```

Elle revient ensuite aux rappels de touches — le message est une confirmation, pas un état. L'état, c'est le titre sans son étoile.

## Étape 6 — Regarder le fichier de l'extérieur

Quittez l'éditeur avec **Alt-X**. Le terminal revient tel qu'il était.

Vérifiez ce que nous avons écrit :

```bash
cat main.py
```

Vous devriez voir :

```python
def greet(name):
    message = f"Hello from {name}!"
    print(message)
greet("Turbo Python")
```

## Étape 7 — L'exécuter

```bash
uv run main.py
```

Le premier lancement fabrique l'environnement, vous verrez donc une ligne ou deux d'uv avant la sortie :

```
Using CPython 3.14.4 interpreter at: /usr/bin/python3.14
Creating virtual environment at: .venv
Hello from Turbo Python!
```

C'est un programme Python qui marche, écrit entièrement dans l'éditeur.

## Étape 8 — Changer de thème

Rouvrez le fichier :

```bash
$TURBO main.py
```

Appuyez sur **F10**. Le menu `File` s'ouvre. Appuyez cinq fois sur **→** : le menu longe la barre jusqu'à `Options`, dont la première entrée, `Theme…`, est surlignée. Appuyez sur **Entrée**.

Une liste de onze apparaît, par ordre alphabétique, le thème courant déjà surligné :

```
borland-light
cappuccino
catppuccin-frappe
catppuccin-latte
cobalt
darcula
intellij-light
monochrome-dark
monochrome-light
turbo-classic
turbo-dark
```

`turbo-classic` est la ligne surlignée, parce que c'est le thème dans lequel vous êtes. Appuyez une fois sur **↓** pour aller à `turbo-dark`, puis sur **Entrée**.

Tout l'éditeur se repeint en gris sombre, et la barre d'état affiche `Theme: Turbo Dark`.

Appuyez sur **Alt-X** pour sortir.

## Et maintenant ?

Vous avez compilé l'éditeur, écrit un programme Python dedans, l'avez enregistré, exécuté, et vous avez changé son apparence.

- Pour faire des choses précises — activer la complétion, écrire votre propre thème, chercher dans un fichier → voir les [guides pratiques](../how-to/)
- Pour retrouver une touche ou une entrée de menu → voir la [référence](../reference/)
- Pour comprendre comment la coloration et la complétion fonctionnent vraiment → voir les [explications](../explanation/)