(prog.formel.variables)=
# Variables

Dans ce chapitre, nous introduisons les variables : comment nommer une valeur, la stocker et la manipuler. Nous allons voir que :

- une **variable** possède un nom, une valeur et un type,
- l'opérateur `=` permet d'**affecter** une valeur à une variable,
- Python distingue quatre types de base : `int`, `float`, `str`, `bool`,
- les **opérateurs** permettent de calculer et comparer des valeurs,
- les noms de variables obéissent à des **règles** et des **conventions**.

## La variable

Une **variable** est un espace en mémoire identifié par un nom. Elle possède trois caractéristiques :

- son **nom** : l'étiquette qui permet de l'identifier,
- sa **valeur** : la donnée stockée,
- son **type** : la nature de cette donnée.

```{codeplay}
age = 17        # nom: age    | valeur: 17      | type: int
pi = 3.14       # nom: pi     | valeur: 3.14    | type: float
prenom = "Ada"  # nom: prenom | valeur: "Ada"   | type: str
majeur = True   # nom: majeur | valeur: True    | type: bool
```

## Déclaration et affectation

**Déclarer** une variable, c'est la créer pour la première fois.
**Affecter** une valeur, c'est la stocker dans la variable avec `=`.
En Python, les deux se font en une seule étape.

```{warning}
Le `=` n'est pas l'égalité mathématique. Il signifie « reçoit la valeur de ». L'instruction `10 = x` est une erreur.
```

Quand une variable apparaît à droite du `=`, Python évalue d'abord le membre droit, puis affecte le résultat.

```{codeplay}
x = 5
x = x * 2    # calcule 5 * 2 = 10, puis affecte 10 à x
```

Une réaffectation **remplace** l'ancienne valeur.

```{exercise}
Que valent `x` et `y` à la fin ? Vérifiez vos réponses.

    x = 2
    y = 3
    y = y - x
    x = x * y
```

```{exercise}
Tracez l'exécution pas à pas et déterminez les valeurs finales.

    a = 10
    b = 3
    a = a + b
    b = a - b
    a = a - b
```

## Les quatre types de base

| Type    | Description              | Exemples              |
|---------|--------------------------|-----------------------|
| `int`   | Nombre entier            | `42`, `-7`, `0`       |
| `float` | Nombre à virgule (point) | `3.14`, `-0.5`, `2.0` |
| `str`   | Chaîne de caractères     | `"bonjour"`, `'abc'`  |
| `bool`  | Valeur logique           | `True`, `False`       |

```{warning}
`"42"` est un `str`, pas un `int`. `True` et `False` prennent une majuscule. La décimale s'écrit avec un point : `3.14`, pas `3,14`.
```

```{question}
Quel est le type de `"False"` ?

{f}`bool`
{v}`str`
{f}`int`
{f}`float`
```

```{question}
Quel est le type de `13 / 3` ?

{f}`int`
{v}`float`
{f}`str`
{f}`bool`
```

```{question}
Quel est le type de `13 // 3` ?

{v}`int`
{f}`float`
{f}`str`
{f}`bool`
```

```{question}
Quel est le type de `13 > 3` ?

{f}`int`
{f}`float`
{f}`str`
{v}`bool`
```

## Les opérateurs

### Opérateurs arithmétiques (sur `int` et `float`)

| Opérateur | Signification               | Exemple  | Résultat |
|-----------|-----------------------------|----------|----------|
| `+`       | Addition                    | `7 + 3`  | `10`     |
| `-`       | Soustraction                | `7 - 3`  | `4`      |
| `*`       | Multiplication              | `7 * 3`  | `21`     |
| `/`       | Division (donne un `float`) | `7 / 2`  | `3.5`    |
| `//`      | Division entière            | `7 // 2` | `3`      |
| `%`       | Modulo (reste)              | `7 % 2`  | `1`      |
| `**`      | Puissance                   | `2 ** 8` | `256`    |

La priorité suit les règles mathématiques habituelles. En cas de doute, utilisez des parenthèses.

```{codeplay}
2 + 3 * 4     # 14, pas 20
(2 + 3) * 4   # 20
```

### Opérateurs de comparaison (retournent un `bool`)

| `==` | `!=` | `<` | `>` | `<=` | `>=` |
|------|------|-----|-----|------|------|
| égal | différent | inférieur | supérieur | inf. ou égal | sup. ou égal |

```{warning}
Ne pas confondre `=` (affectation) et `==` (comparaison d'égalité).
```

### Opérateurs logiques (sur `bool`)

| `and` | `or` | `not` |
|-------|------|-------|
| vrai si les deux sont vrais | vrai si au moins un est vrai | inverse la valeur |

### Concaténation (sur `str`)

`+` colle deux chaînes ; `*` répète une chaîne.

```{codeplay}
"bon" + "jour"   # "bonjour"
"ha" * 3         # "hahaha"
```

```{question}
Quel est le résultat de `10 % 3` ?

{v}`1`
{f}`2`
{f}`3`
{f}`3.333`
```

```{exercise}
Sans exécuter le code, trouvez les valeurs finales de `x` et `y`.

    x = 2
    y = 3
    x = x == y
```

```{exercise}
Même exercice.

    x = 2
    y = 3
    y = x % y
    x = x * 2
```

```{exercise}
Même exercice.

    x = 2
    y = 3
    x = x < y
    y = not x
```

## Nommer les variables

### Règles obligatoires

- Commence par une lettre ou `_`, jamais par un chiffre.
- Contient uniquement des lettres, chiffres ou `_` — pas d'espace, pas de `-`, pas d'accent.
- Sensible à la casse : `age`, `Age` et `AGE` sont trois variables différentes.
- N'utilise pas un mot réservé : `if`, `for`, `while`, `True`, `False`, `and`, `or`, `not`, `def`…

```{codeplay}
# Invalide — SyntaxError
2eme = "deuxième"   # commence par un chiffre
mon age = 18        # espace interdit
for = 5             # mot réservé
```

### Conventions recommandées (PEP 8)

Utiliser le **snake_case** : mots en minuscules séparés par `_`. Choisir des noms explicites.

```{codeplay}
# Bien
temperature_celsius = 36.6
est_majeur = True
nombre_etudiants = 28

# A eviter
t = 36.6
e = True
n = 28
```

```{exercise}
Parmi ces noms, lesquels sont valides en Python ?

`mon_score`  `3points`  `prix-unitaire`  `variable`  `est_valide`  `class`  `_temp`
```

## Erreurs fréquentes

```{exercise}
Trouvez et corrigez l'erreur.

    x = 5
    y = x + z
```

```{exercise}
Trouvez et corrigez l'erreur.

    reponse = "oui"
    if reponse = "oui":
        pass
```

```{exercise}
Trouvez et corrigez l'erreur.

    vrai = true
    faux = False
```