Variables, types et affectation

Une variable est une case de la mémoire, désignée par un nom, qui contient une valeur d'un certain type ; l'affectation est l'instruction qui range une valeur dans cette case. Ce chapitre présente les types simples (entier, réel, booléen, chaîne), l'affectation, la saisie et l'affichage, puis les opérateurs et les conversions, en pseudo-code et en Python.

C'est quoi une variable ?

Un programme manipule des données : une note, un prix, un nom d'utilisateur. Pour s'en servir plusieurs fois, il faut les garder quelque part. Une variable est une boîte étiquetée : l'étiquette est son nom (on dit aussi identifiant), le contenu est sa valeur, et la forme de la boîte est son type, qui fixe ce qu'elle peut contenir et les opérations permises.

Une boîte ne contient qu'une valeur à la fois. Quand tu ranges une nouvelle valeur, l'ancienne est écrasée : c'est l'origine de la plupart des erreurs de débutant dans les échanges de valeurs et les boucles.

Nommer ses variables

Les règles sont presque les mêmes dans tous les langages : un nom commence par une lettre (ou _), continue avec des lettres, des chiffres et des _, sans espace ni tiret, et ne peut pas être un mot réservé du langage (if, for, while, def, return, class…). Python distingue les majuscules : Total et total sont deux variables différentes.

Au-delà des règles, un bon nom dit ce que contient la variable :

En Python, la convention (le guide de style PEP 8) est le snake_case : minuscules et _ (nb_postes). En C# et en JavaScript, tu écriras plutôt nbPostes (camelCase). Les compteurs de boucle s'appellent traditionnellement i, j, k : c'est la seule exception admise aux noms d'une lettre.

Les types simples

Le programme de BTS cite quatre types simples, plus la chaîne de caractères.

La fonction type donne le type d'une valeur :

print(type(7), type(7.0), type("7"), type(True))
print(type(7 / 7))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>
<class 'float'>

7, 7.0 et "7" sont trois valeurs différentes : un entier, un réel et un texte d'un seul caractère. La division / donne toujours un réel en Python, même quand elle tombe juste.

Données mathématiques et données informatiques

En maths, un entier peut être aussi grand que tu veux et un réel a une infinité de décimales. Une machine stocke tout sur un nombre fini de bits : le programme te demande de connaître ces différences, sans le détail de la représentation interne.

Les entiers. En Python, un int n'a pas de limite pratique : 2 ** 64 donne 18446744073709551616 sans broncher. En C# ou en Java, un int occupe 32 bits et va de −2 147 483 648 à 2 147 483 647 : au-delà, la valeur « déborde » et repart dans les négatifs, sans message. Tu le rencontreras en SLAM.

Les réels. Un float est stocké en binaire sur 64 bits, avec environ 15 à 17 chiffres significatifs. Beaucoup de décimales simples, comme 0,1, n'ont pas d'écriture binaire exacte (comme 1/3 n'a pas d'écriture décimale exacte). D'où ce résultat célèbre :

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

Les booléens. Une condition comme note >= 10 a pour valeur True ou False. On peut ranger ce résultat dans une variable : admis = note >= 10. Les booléens servent dans les conditions (chapitre 3) et les boucles.

Les chaînes. Une chaîne est une suite de caractères. Le programme recommande de la traiter comme un type à part entière, avec ses propres opérations (concaténation, extraction, recherche), plutôt que comme un tableau de caractères. Le chapitre 9 lui est consacré.

L'affectation

L'affectation range une valeur dans une variable. En pseudo-code, on l'écrit avec une flèche ← ; en Python, avec =.

nb_postes ← 25
prix ← 149,90
total ← nb_postes × prix

Elle se lit de droite à gauche : on calcule d'abord l'expression de droite avec les valeurs actuelles, puis on range le résultat dans la variable de gauche. D'où l'instruction qui choque les matheux :

compteur ← compteur + 1

En maths, c = c + 1 n'a pas de solution. En algorithmique, c'est une action : « la nouvelle valeur de compteur est l'ancienne plus 1 ». Le programme appelle cela une affectation récursive : la variable apparaît des deux côtés. C'est le cœur des compteurs et des accumulateurs (chapitre 4).

Pour suivre des affectations successives, on fait un tableau de trace : une colonne par variable, une ligne par instruction (chapitre 5).

a ← 5
b ← a + 2
a ← a × b
b ← b - a

Avant sa première affectation, b n'a pas de valeur connue (le ?). Utiliser une variable non initialisée est une erreur : Python lève NameError: name 'b' is not defined, d'autres langages prennent une valeur au hasard.

Échanger deux variables

Échanger le contenu de a et b est l'exercice classique de l'affectation. La tentative naïve échoue :

a ← b
b ← a

Avec a = 3 et b = 8, la première ligne écrase le 3 : a vaut 8, puis b ← a remet 8 dans b. Les deux variables valent 8. Il faut une troisième boîte pour garder la valeur qu'on va écraser :

temp ← a
a ← b
b ← temp

Python sait échanger en une ligne, grâce à l'affectation multiple : a, b = b, a. Python évalue d'abord tout le côté droit (le couple (8, 3)), puis l'affecte. Connais les deux : la version avec temp est celle qu'on attend dans un algorithme, et elle fonctionne dans tous les langages.

Saisir et afficher

Saisir(x) lit une valeur au clavier et la range dans x. Afficher(...) écrit à l'écran. En Python :

Le programme limite la mise en forme exigible aux séparateurs et aux retours à la ligne : les f-strings sont un confort, pas une obligation.

Les opérateurs numériques

DIV et MOD reviennent sans cesse : n MOD 2 = 0 teste si n est pair, n MOD 10 donne le chiffre des unités, n DIV 10 enlève ce chiffre, secondes DIV 60 donne des minutes. Le lien avec la division euclidienne (17 = 5 × 3 + 2) est fait dans le cours d'arithmétique, au chapitre division euclidienne.

Les priorités sont celles des maths : puissance, puis *, /, //, %, puis + et -. Les parenthèses lèvent le doute : 2 + 3 * 4 vaut 14, (2 + 3) * 4 vaut 20.

Traduire une formule

Une formule écrite « en deux dimensions » (fraction, racine, exposant) doit être mise en ligne. Le programme demande de savoir le faire dans les deux sens.

L'oubli le plus fréquent concerne le dénominateur : a + b / 2 * c calcule a + (b/2)·c. Mets des parenthèses autour de tout numérateur et de tout dénominateur qui contient une opération.

Les fonctions mathématiques usuelles

Le programme inclut les fonctions d'arrondi et un générateur de nombres pseudo-aléatoires. En Python, certaines sont disponibles directement, les autres sont dans les modules math et random.

import math
import random

print(round(3.14159, 2))   # arrondi à 2 décimales
print(int(3.9), int(-3.9)) # troncature : on coupe la partie décimale
print(math.floor(-3.7), math.ceil(3.2))  # partie entière inférieure, supérieure
print(math.sqrt(16))
de = random.randint(1, 6)  # entier au hasard entre 1 et 6 inclus
print(1 <= de <= 6)

3.14
3 -3
-4 4
4.0
True

Comparer des valeurs

Les opérateurs de comparaison donnent un booléen. On compare des nombres entre eux ou des chaînes entre elles.

Les chaînes se comparent caractère par caractère, selon le code de chaque caractère : c'est l'ordre du dictionnaire pour des mots en minuscules sans accent, mais toutes les majuscules passent avant les minuscules ("Z" < "a" est vrai) et "10" est avant "9", car "1" est avant "9". Pour comparer des nombres saisis, convertis-les d'abord.

Python accepte aussi les comparaisons chaînées, comme en maths : 0 <= note <= 20.

Les opérateurs booléens

Ils combinent des conditions. Le programme cite non, et, ou et oux (ou exclusif).

Les tables de vérité, les lois de De Morgan et la simplification d'expressions sont au cours d'algèbre de Boole. Retiens ici les deux lois qui servent tous les jours : NON (a ET b) équivaut à (NON a) OU (NON b), et NON (a OU b) équivaut à (NON a) ET (NON b). Par exemple, « la note n'est pas entre 0 et 20 » s'écrit note < 0 or note > 20.

L'évaluation partielle. Python, comme la plupart des langages, s'arrête dès que le résultat est connu : dans a and b, si a est faux, b n'est pas évalué ; dans a or b, si a est vrai, b n'est pas évalué. C'est utile pour se protéger :

nb = 0
total = 50
if nb != 0 and total / nb > 10:
    print("Moyenne supérieure à 10")
else:
    print("Pas de moyenne calculable ou moyenne trop basse")

Si nb vaut 0, la division n'est jamais calculée : pas d'erreur ZeroDivisionError. Inverse les deux conditions et le programme plante. Le programme du BTS cite justement l'évaluation partielle parmi les effets à connaître.

Les opérateurs bit à bit

Un entier est stocké en binaire ; les opérateurs bit à bit travaillent sur chaque bit séparément. Le programme demande de les interpréter en termes de masque, de mise à un, de mise à zéro et de changement d'état.

Une application de gestion des droits code les permissions sur des bits : lecture = 1 (001), écriture = 2 (010), suppression = 4 (100).

LECTURE, ECRITURE, SUPPRESSION = 1, 2, 4

droits = LECTURE | ECRITURE      # mise à un de deux bits : 011, soit 3
print(droits)
print(droits & SUPPRESSION != 0) # masque : le bit suppression est-il à 1 ?
droits = droits | SUPPRESSION    # mise à un : 111, soit 7
droits = droits & ~ECRITURE      # mise à zéro : 101, soit 5
print(droits)
droits = droits ^ LECTURE        # changement d'état : 100, soit 4
print(droits)

3
False
5
4

Le même calcul donne l'adresse d'un réseau : on fait un ET entre l'adresse IP et le masque de sous-réseau, octet par octet. Pour 192.168.1.200 avec le masque 255.255.255.192, le dernier octet donne 200 & 192 = 11001000 & 11000000 = 11000000 = 192 : le réseau est 192.168.1.192. Le cours de réseaux détaille le calcul, et le chapitre 11 montre comment convertir en binaire.

Convertir un type en un autre

Le transtypage (ou conversion) transforme une valeur d'un type en un autre. Il est indispensable après une saisie, et piégeux quand la conversion perd de l'information.

Quand une saisie peut être invalide, il faut contrôler avant de convertir, par exemple avec texte.isdigit() (vrai si la chaîne ne contient que des chiffres), ou intercepter l'erreur avec try/except (chapitre 5).

Exercices

x ← 4
y ← x × 3
z ← y - x
x ← z + y
y ← y MOD 5
z ← z DIV 3

temp ← a      // temp = 1
a ← b         // a = 2
b ← c         // b = 3
c ← temp      // c = 1

Algorithme ConvertirDuree
// Entrée : total (entier), une durée en secondes
// Sortie : la durée en h, min, s, affichée
Variables
    total, h, m, s : entier
Début
    Saisir(total)
    h ← total DIV 3600
    m ← (total MOD 3600) DIV 60
    s ← total MOD 60
    Afficher(h, " h ", m, " min ", s, " s")
Fin

total = int(input("Durée en secondes ? "))
h = total // 3600
m = (total % 3600) // 60
s = total % 60
print(h, "h", m, "min", s, "s")

print(17 / 4, 17 // 4, 17 % 4)
print("3" + "4", 3 + 4)
print(int("12") * 2, "12" * 2)
print(10 / 5)
print(int(7.99), round(7.99))
print("Paris" < "lyon")

4.25 4 1
34 7
24 1212
2.0
7 8
True