Variables et types en Python

📦 Le cours : variables, types et conditions

Un programme manipule des valeurs : un nombre, un texte, un « oui / non ». Une variable est un nom qui désigne une valeur gardée en mémoire. On la crée avec l'affectation = et on s'en sert ensuite partout dans le programme. Python n'oblige pas à déclarer un type : c'est la valeur qui le porte, et une même variable peut recevoir plus tard une valeur d'un autre type.

Affecter une variable

Le signe = n'est pas une égalité mathématique : il se lit « age reçoit la valeur de droite ». Python calcule d'abord le membre de droite, puis range le résultat dans la variable. C'est pourquoi age = age + 1 est parfaitement légitime.

age = 16
print(age)
age = age + 1
print(age)
age = "seize"
print(age, type(age))

16
17
seize <class 'str'>

Les types de base

print(type(16), type(3.14), type("NSI"))
print(type(True), type(None))
print(10 ** 30)
print(isinstance(3, int), isinstance(3, float), isinstance(True, int))
print(True + True)

<class 'int'> <class 'float'> <class 'str'>
<class 'bool'> <class 'NoneType'>
1000000000000000000000000000000
True False True
2

Les entiers de Python n'ont pas de limite de taille (contrairement au C ou au Java). Et bool est un sous-type de int : True vaut 1 et False vaut 0, d'où True + True égal à 2.

Bien nommer ses variables

Un nom est formé de lettres, de chiffres et du tiret bas _, sans commencer par un chiffre ; il ne peut pas être un mot réservé du langage (class, if, for…). Python distingue majuscules et minuscules. Par convention, on écrit en minuscules avec des tirets bas (nb_eleves, note_finale) et on choisit un nom qui dit ce que la variable contient.

import keyword

nb_eleves = 28
Nb_eleves = 30
print(nb_eleves, Nb_eleves)
print(keyword.iskeyword("class"), keyword.iskeyword("classe"))

28 30
True False

Opérateurs arithmétiques

print(7 / 2, 7 // 2, 7 % 2)
print(2 ** 10, 10 / 5)
print(-7 // 2, -7 % 2)
print(divmod(17, 5))

3.5 3 1
1024 2.0
-4 1
(3, 2)

Le quotient // arrondit vers le bas : -7 // 2 vaut -4, pas -3. Dans tous les cas, a == (a // b) * b + a % b. divmod(a, b) renvoie les deux résultats d'un coup.

Ces deux opérateurs servent tout le temps : n % 2 == 0 teste si n est pair, n % 10 donne le dernier chiffre de n, n // 10 retire ce dernier chiffre, et on convertit des durées avec des divisions successives.

secondes = 3725
heures = secondes // 3600
minutes = (secondes % 3600) // 60
reste = secondes % 60
print(f"{heures} h {minutes} min {reste} s")
print(2025 % 10, 2025 // 10)

1 h 2 min 5 s
5 202

Priorités et parenthèses

Python applique les priorités usuelles : d'abord **, puis *, /, //, %, puis + et -, puis les comparaisons, enfin not, and, or. En cas de doute, ajoute des parenthèses : elles rendent le code plus lisible.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(2 ** 3 ** 2)
print(-2 ** 2, (-2) ** 2)

14
20
512
-4 4

Deux pièges : ** se calcule de droite à gauche (2 ** 3 ** 2 vaut 2 ** 9), et le signe moins d'un -2 ** 2 s'applique après la puissance.

Affectations composées

Pour modifier une variable à partir de sa valeur actuelle, on écrit +=, -=, *=, /=, //=, %= ou **=. x += 1 est un raccourci pour x = x + 1.

score = 10
score += 5
score *= 2
score -= 1
score //= 3
print(score)

9

Convertir un type en un autre

Les fonctions int(), float(), str() et bool() convertissent une valeur. int() tronque vers zéro (elle n'arrondit pas), round() arrondit à l'entier le plus proche.

print(int("42") + 1, float("3.5") * 2, str(12) + "0")
print(int(3.9), int(-3.9), round(3.9))
print(float(7), bool(0), bool(""), bool("0"), bool([]))

43 7.0 120
3 -3 4
7.0 False False True False

bool() répond « faux » pour 0, 0.0, la chaîne vide, une liste ou un dictionnaire vide et None, et « vrai » pour tout le reste (même la chaîne "0", qui n'est pas vide). Cette règle sert dans les conditions : if liste: signifie « si la liste n'est pas vide ».

for valeur in [0, 1, "", "NSI", [], [0], None]:
    print(repr(valeur), bool(valeur))

0 False
1 True
'' False
'NSI' True
[] False
[0] True
None False

Comparer et combiner des conditions

Une comparaison (==, !=, <, >, <=, >=) produit un booléen. On les combine avec and (les deux), or (au moins une) et not (le contraire). Python accepte les comparaisons enchaînées : 0 <= x < 10 signifie « x est entre 0 inclus et 10 exclu ».

x = 7
print(x > 5, x == 7, x != 7)
print(0 <= x < 10, 10 <= x < 20)
print(x > 5 and x % 2 == 0, x > 5 or x % 2 == 0, not x > 5)
print("a" < "b", "Z" < "a", "10" < "9")

True True False
True False
False True False
True True True

Les textes se comparent dans l'ordre des codes de leurs caractères : toutes les majuscules passent avant les minuscules ("Z" < "a"), et "10" < "9" est vrai car on compare caractère par caractère ("1" avant "9").

Afficher avec print et les f-strings

print accepte plusieurs valeurs séparées par des virgules (une espace les sépare), et deux options : sep change le séparateur, end change ce qui termine la ligne. Une f-string (chaîne préfixée par f) insère des valeurs entre accolades ; après :, une spécification règle le format.

prenom = "Lina"
note = 17.5
print("Bonjour", prenom)
print("a", "b", "c", sep="-")
print("Chargement", end="...")
print("terminé")
print(f"{prenom} a {note}/20")
print(f"{note:.2f} | {42:05d} | {1234567:,} | {0.256:.1%}")
print(f"{prenom:>8}|{prenom:<8}|{prenom:^8}|")
print(f"{note * 2 = }")

Bonjour Lina
a-b-c
Chargement...terminé
Lina a 17.5/20
17.50 | 00042 | 1,234,567 | 25.6%
    Lina|Lina    |  Lina  |
note * 2 = 35.0

Lire une saisie avec input

input(message) affiche le message, attend que l'utilisateur tape sa réponse puis la renvoie toujours sous forme de texte. Pour calculer, il faut convertir la saisie avec int() ou float().

prenom = input("Ton prénom : ")
age = int(input("Ton âge : "))
print(f"Dans un an, {prenom} aura {age + 1} ans.")

Dans un an, Lina aura 17 ans.

if, elif, else : choisir quoi exécuter

Une instruction if teste une condition ; si elle est vraie, le bloc indenté qui suit s'exécute. elif (« sinon si ») propose une autre condition, else couvre tous les autres cas. Les branches sont examinées dans l'ordre et une seule est exécutée. L'indentation (quatre espaces) fait partie de la syntaxe, et chaque ligne d'en-tête se termine par :.

temperature = 28
if temperature >= 30:
    print("Canicule")
elif temperature >= 20:
    print("Il fait bon")
elif temperature >= 10:
    print("Frais")
else:
    print("Froid")
print("Fin du test")

Il fait bon
Fin du test

Le dernier print n'est pas indenté : il appartient au programme principal et s'exécute dans tous les cas. L'ordre des branches compte : si on testait temperature >= 10 en premier, les 28 degrés tomberaient dans cette branche.

On combine des conditions avec and et or. Exemple classique : une année est bissextile si elle est divisible par 400, ou si elle est divisible par 4 sans l'être par 100.

annee = 2100
if annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0):
    print(annee, "est bissextile")
else:
    print(annee, "n'est pas bissextile")

2100 n'est pas bissextile

L'expression conditionnelle

Quand il s'agit seulement de choisir entre deux valeurs, on peut écrire une expression sur une ligne : valeur_si_vrai if condition else valeur_si_faux.

age = 20
statut = "majeur" if age >= 18 else "mineur"
x = -5
valeur_absolue = x if x >= 0 else -x
print(statut, valeur_absolue)

majeur 5

⚠️ Erreurs fréquentes

= au lieu de == dans une condition

= affecte une valeur ; == compare deux valeurs. Dans une condition, écrire = provoque une SyntaxError.

x = 5
if x = 5:
    print("cinq")

x = 5
if x == 5:
    print("cinq")

cinq

Les décimaux ne sont pas exacts

Les float sont stockés en binaire : 0.1, par exemple, n'a pas d'écriture exacte. On ne compare donc jamais deux décimaux avec == : on utilise math.isclose ou on arrondit.

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

0.30000000000000004
False

import math

print(math.isclose(0.1 + 0.2, 0.3))
print(round(0.1 + 0.2, 2) == 0.3)

True
True

Un texte n'est pas un nombre

Ce que renvoie input() est un str. Additionner un texte et un entier est une TypeError : il faut convertir.

age = "17"
print(age + 1)

TypeError: can only concatenate str (not "int") to str

age = "17"
print(int(age) + 1)

18

int() ne comprend pas tous les textes

int("3.5") échoue (ValueError) : le texte n'est pas un entier. Passe par float si le texte peut contenir une virgule décimale (avec un point, pas une virgule : float("3,5") échoue aussi).

print(int("3.5"))

ValueError: invalid literal for int() with base 10: '3.5'

print(int(float("3.5")))

3

Une variable qui n'existe pas

Une faute de frappe dans un nom crée une NameError : Python ne devine rien. Relis le message d'erreur, il contient le nom fautif.

total = 12
print(valeur_inconnue)

NameError: name 'valeur_inconnue' is not defined

/ renvoie toujours un décimal

10 / 2 vaut 5.0 et non 5. Pour obtenir un entier (par exemple pour un indice), utilise //.

notes = [10, 12, 14, 16]
milieu = len(notes) / 2
print(notes[milieu])

TypeError: list indices must be integers or slices, not float

notes = [10, 12, 14, 16]
milieu = len(notes) // 2
print(notes[milieu])

14

round() arrondit parfois au pair

Pour un nombre exactement entre deux entiers (x.5), round choisit l'entier pair : c'est la règle d'arrondi de Python.

print(round(0.5), round(1.5), round(2.5), round(3.5))
print(int(2.5 + 0.5))

0 2 2 4
3

== compare les valeurs, is compare l'identité

a = [1, 2]
b = [1, 2]
print(a == b, a is b)

True False

Deux listes de même contenu sont égales (==) mais ce sont deux objets distincts (is est faux). is ne sert en pratique que pour comparer à None : if x is None:.

Oublier les deux-points ou l'indentation

Chaque if, elif, else se termine par : et son bloc est indenté d'un cran. Sans cela, Python lève une SyntaxError ou une IndentationError. Garde la même indentation (quatre espaces) dans tout le fichier.

note = 12
if note >= 10
print("reçu")

note = 12
if note >= 10:
    print("reçu")

reçu

📋 Aide-mémoire

• Types : int, float, str, bool, NoneType ; type(x) donne le type, isinstance(x, int) le teste.
• Arithmétique : + - * / // % ** ; // et % arrondissent vers le bas (-7 // 2 donne -4) ; divmod(a, b) renvoie le couple.
• Priorités : ** avant * / // % avant + - avant les comparaisons avant not, and, or ; en cas de doute, des parenthèses.
• Conversions : int() tronque, round() arrondit (au pair pour x.5), float(), str(), bool() ; input() renvoie toujours un str.
• Faux : 0, 0.0, "", [], {}, None ; tout le reste est vrai.
• Comparer des décimaux : math.isclose(a, b) (jamais ==) ; comparer à None : is None.
• f-string : f"{x}", f"{x:.2f}", f"{x:>8}", f"{x = }" (affiche le nom et la valeur).
• Condition : if / elif / else avec : et quatre espaces d'indentation ; a if cond else b pour choisir une valeur.