Les bases de Python : valeurs, variables et expressions

Un programme est une suite d’instructions. L’interpréteur Python lit le code Python et exécute ces instructions. Utilise Python 3, où un appel comme print("Hello") comporte des parenthèses.

Essaie une ligne dans la console

La console interactive, ou REPL, affiche >>> lorsqu’elle est prête à recevoir du code Python. Saisis une instruction après l’invite et appuie sur Entrée. Tu ne saisis pas toi-même >>>.

>>> 3 + 4
7
>>> "hi"
'hi'

La console affiche automatiquement la valeur d’une expression. Elle place des guillemets autour d’une chaîne pour l’identifier comme du texte. Une invite ... signifie qu’une instruction est inachevée et que Python attend la suite. Par exemple, une parenthèse ouvrante peut encore avoir besoin de sa parenthèse fermante. Saisis exit() à une invite prête à recevoir une instruction pour quitter la console.

La console est utile pour tester une expression. Elle peut conserver un historique des commandes, mais cet historique n’est pas un programme enregistré. Place dans un script les instructions que tu souhaites exécuter à nouveau ensemble.

Enregistre et exécute un script

Un script est un fichier de code en texte brut portant l’extension .py. Utilise un éditeur de code comme IDLE, Thonny ou VS Code. IDLE est fourni avec la distribution standard de Python. Un traitement de texte peut remplacer les guillemets droits par des guillemets typographiques ; ces derniers ne peuvent pas délimiter des chaînes Python.

Saisis ces lignes dans l’éditeur et enregistre le script :

print("Hello, world!")
print("Welcome to Python.")

Dans IDLE, choisis Run → Run Module ou appuie sur F5. L’affichage est le suivant :

Hello, world!
Welcome to Python.

Python exécute ces instructions de haut en bas. Chaque print() affiche son texte et passe à la ligne. Inverser les instructions inverse l’ordre de l’affichage.

Tu peux aussi exécuter un script enregistré depuis un terminal. Ouvre le dossier qui contient ton script, puis saisis la commande de l’interpréteur suivie du nom sous lequel le script est enregistré. Sur macOS ou Linux, la commande est généralement python3 suivie du nom du script ; Windows utilise couramment python ou py. La commande du terminal démarre l’interpréteur et lui indique quel script exécuter. Cette commande se saisit à l’invite du terminal, pas après le >>> de Python. Un éditeur en ligne peut proposer un bouton d’exécution à la place.

Détermine ce qui doit être affiché

Un script contenant uniquement 3 + 4 calcule une valeur mais n’affiche rien. Écris print(3 + 4) pour afficher 7. De même, print("hi") affiche le texte sans les guillemets qui l’entourent. Les guillemets appartiennent au code ; ils marquent le début et la fin du texte.

Python est sensible à la casse. print et Print sont des noms différents, donc Print("hi") produit une NameError, sauf si cet autre nom a été défini. Respecte exactement l’orthographe et la casse des noms natifs.

Les espaces en début de ligne ont aussi un sens. Pour ces suites d’instructions simples, commence chaque instruction à la marge gauche. Une indentation involontaire avant print("hi") peut provoquer IndentationError: unexpected indent. Les espaces à l’intérieur du texte entre guillemets sont différents : Python les affiche comme faisant partie du message.

Une erreur dans un programme est un bug. La rechercher et la corriger s’appelle le débogage. Détermine d’abord le type de problème : du code que Python ne peut pas lire, une opération qui échoue pendant l’exécution ou un résultat simplement incorrect.

Trois types de problèmes

Python vérifie la syntaxe du script entier avant de l’exécuter. Une erreur de syntaxe vers la fin empêche même la première ligne de s’exécuter. Une erreur d’exécution est différente : les instructions précédentes ont déjà été exécutées et leur affichage reste visible.

Pour la moyenne, la division a lieu avant l’addition. Python calcule 92 / 2, soit 46.0, puis ajoute 88 pour obtenir 134.0. L’expression voulue est (88 + 92) / 2, qui donne 90.0. Aucun message d’erreur n’apparaît, car les deux expressions sont valides. Un calcul à la main te donne un résultat à comparer avec celui du programme.

Lis une trace d’appels en commençant par le bas

Supposons que le code soit :

name = "Ada"
print("Hello", nme)

La trace d’appels se termine par un message comme NameError: name 'nme' is not defined. La dernière ligne nomme l’erreur et explique ce qui a échoué. Au-dessus, Python indique l’emplacement, le numéro de ligne et le code. Compare nme avec le nom affecté plus haut : name. Corriger cette orthographe permet d’obtenir l’affichage Hello Ada.

L’emplacement indiqué est celui où Python a remarqué le problème. Si une ligne semble correcte, vérifie aussi celle qui la précède. Un guillemet ou une parenthèse manquante plus haut peut empêcher Python de comprendre la suite. Les versions récentes pointent souvent directement vers la parenthèse ouvrante sans correspondance.

Laisse le type d’erreur guider ta recherche

• NameError : Python ne trouve pas un nom, comme avec pirnt, Print ou une variable utilisée avant son affectation. Vérifie l’orthographe, la casse et l’ordre des lignes.
• TypeError : l’opération ne fonctionne pas avec ces types. "5" + 5 tente d’assembler du texte et un nombre.
• ValueError : une conversion reçoit un contenu inutilisable. int("abc") reçoit du texte, mais ce texte ne décrit pas un entier.
• ZeroDivisionError : un diviseur vaut zéro. Examine la valeur utilisée après /, // ou %.

Pour une SyntaxError, associe chaque guillemet et chaque parenthèse ouvrante à son élément fermant. print('It's late') ferme la chaîne à l’apostrophe de « It's » ; utilise print("It's late"). Le code Python 2 comme print "hi" a besoin des parenthèses de Python 3 : print("hi"). Remplace les guillemets typographiques par des guillemets droits. En cas d’indentation inattendue, supprime les espaces superflus en début de ligne.

Corrige un problème, puis exécute à nouveau le programme. Le premier échec a pu empêcher Python d’atteindre un second problème. Construis un programme quelques lignes à la fois pour que chaque nouvel échec laisse une petite zone à examiner.

Le code indique à Python ce qu’il doit faire. Un commentaire indique à une personne pourquoi le code le fait ou ce que signifie une valeur. Python ignore un commentaire lorsqu’il exécute le programme.

Délimite clairement le commentaire

Un commentaire commence par # en dehors d’une chaîne et se poursuit jusqu’à la fin de la ligne. Il peut être seul ou suivre une instruction :

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

Le commentaire qui occupe toute une ligne explique le but du programme. Le commentaire en fin de ligne suit du code sur la même ligne. PEP 8, le guide de style de Python, recommande au moins deux espaces avant le # d’un commentaire en fin de ligne et un espace après. Cet espacement rend la séparation facile à voir.

Un croisillon entre guillemets est du texte ordinaire :

print("#1 is not a comment")  # This part is a comment.

L’affichage est #1 is not a comment. Python lit toute la chaîne entre guillemets, y compris son croisillon, comme une donnée. Il ignore le texte après le # suivant, car ce signe est en dehors des guillemets.

Explique le sens, pas les étapes évidentes

Compare ces commentaires :

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

Le premier commentaire répète une opération déjà visible dans le code. Le second indique une raison de la modification. Le lecteur sait maintenant ce que la variable compte comme tentative. Un nom clair comme attempts fournit aussi une partie des informations qu’un nom vague laisserait aux commentaires.

Les commentaires utiles expliquent une unité, un choix ou un but que le code seul ne rend pas clair. Par exemple, tax_rate = 0.08 # 8% sales tax relie un taux décimal à son sens. Si tu modifies ce taux plus tard, vérifie aussi le commentaire. Un commentaire périmé peut induire le lecteur en erreur même lorsque le code fonctionne.

Empêche temporairement l’exécution d’une ligne

Pour mettre en commentaire une instruction, place # devant elle :

print("Start")
# print("Checking this step")
print("Finish")

Seuls Start et Finish apparaissent. Mettre une ligne en commentaire permet de la conserver pendant que tu testes le programme sans elle. Supprime l’ancien code désactivé lorsqu’il n’est plus utile ; sinon, un futur lecteur devra deviner s’il est encore nécessaire.

Pour une note sur plusieurs lignes, commence chaque ligne par # :

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

Le texte entre guillemets triples est différent. Une ligne comme """Convert a temperature.""" est une expression de type chaîne, pas un commentaire. À certains emplacements, de telles chaînes peuvent servir de documentation appelée docstring. Utilise # pour un commentaire ordinaire. Une chaîne que rien n’utilise peut rester invisible dans un script, ce qui peut la faire ressembler à un commentaire même si Python la lit comme une valeur.

Une valeur est une donnée, comme 42, 3.5 ou "Ada". Chaque valeur possède un type, qui indique à Python de quelle sorte de donnée il s’agit. Un littéral est une valeur écrite directement dans le code. Son écriture compte : 7, 7.0 et "7" ont des types différents.

Quatre types de base

Un point décimal fait de 2.0 un flottant, même si sa valeur est égale à celle de l’entier 2. Les guillemets font de "42" du texte, même si les caractères ressemblent à un nombre. Le type dépend de la valeur écrite, et non de l’usage qu’un lecteur pourrait en faire.

Les littéraux booléens ont une majuscule initiale et pas de guillemets. True est un booléen ; "True" est une chaîne. Le mot en minuscules true est un nom, et l’utiliser sans le définir produit une NameError. Une comparaison peut produire un booléen : 3 < 5 s’évalue à True.

Demande son type à Python

La fonction native type() indique le type de son argument. Dans la console, ces appels affichent :

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

Dans un script, utilise print() pour voir ces résultats :

print(type(42), type("42"))

Cela affiche <class 'int'> <class 'str'>. Le mot class fait partie de la réponse de Python ; les noms int et str désignent les types.

Les types changent le sens des opérateurs

Avec des nombres, + additionne. Avec deux chaînes, il assemble du texte :

print(5 + 3)
print("5" + "3")

La première ligne affiche 8. La seconde affiche 53. La seconde expression contient deux valeurs textuelles, donc Python assemble leurs caractères. Il n’examine pas les caractères représentant des chiffres pour décider de les additionner.

"5" + 5 lève une TypeError : un opérande est du texte et l’autre est un entier. Vérifie les types lorsqu’une opération se comporte autrement que prévu. En particulier, voir des chiffres à l’écran ne prouve pas que la valeur stockée est numérique.

Choisis un type adapté au sens

Utilise un entier pour un dénombrement et un flottant pour une mesure qui peut comporter une fraction. Conserve un identifiant comme un code postal américain sous forme de texte. La chaîne "02134" préserve le zéro initial ; ce zéro fait partie de l’identité du code et ne sert pas à un calcul. Les numéros de téléphone peuvent aussi contenir des signes de ponctuation qu’il est utile de conserver.

La console peut afficher 'Ada', tandis que print("Ada") affiche Ada. Les deux désignent le même texte. Les guillemets de la console identifient une chaîne ; print() présente les caractères à un lecteur. Aucun de ces affichages ne modifie le type stocké.

Python dispose de types distincts pour les nombres entiers et les nombres en virgule flottante. Les écrire clairement évite les erreurs de syntaxe et les modifications moins évidentes des données.

Écris les dénombrements sous forme d’entiers

Un entier n’a pas de partie fractionnaire. Écris un int sans point décimal, comme 42, 0 ou -7. Les entiers Python peuvent grandir autant que la mémoire disponible le permet, sans limite fixe de taille. L’addition, la soustraction et la multiplication d’entiers sont exactes. Par exemple, 2 ** 100 donne l’entier exact 1267650600228229401496703205376.

N’utilise pas de virgules pour grouper les milliers. Écris 1000000 ou utilise des caractères de soulignement pour faciliter la lecture : 1_000_000. Ces caractères ne changent pas la valeur.

Un littéral entier décimal non nul ne peut pas commencer par un zéro. Écrire 02134 est une erreur de syntaxe. Si ces chiffres forment un identifiant dont le premier zéro compte, écris "02134" comme du texte.

Écris les quantités fractionnaires sous forme de flottants

Un flottant utilise un point décimal ou une notation avec exposant. 3.5, 2.0 et -0.25 sont des flottants. Python accepte aussi .5 et 5., qui signifient 0.5 et 5.0 ; écrire le zéro supplémentaire les rend souvent plus faciles à lire. Utilise des flottants pour des mesures comme la température ou la distance, et pour des calculs d’initiation avec des prix comportant une partie fractionnaire.

Le code Python utilise un point décimal. Une virgule sépare des valeurs ; elle ne marque jamais la partie fractionnaire. Par exemple :

x = 3.5
print(x)

affiche 3.5, tandis que x = 3,5 crée une paire de valeurs, affichée sous la forme (3, 5). De même, x = 1,000 crée (1, 0), et non mille. Ces instructions peuvent s’exécuter : l’absence de message d’erreur ne signifie donc pas que le nombre a été écrit correctement.

Utilise la notation scientifique

La lettre e signifie « multiplié par dix à la puissance » dans un littéral numérique :

Un littéral avec exposant est un flottant même lorsque sa valeur est un entier. Le signe moins après e rend l’exposant négatif, donc 2.5e-3 signifie 2,5 divisé par 1 000.

Attends-toi à une précision limitée

Les flottants stockent les nombres en binaire avec une précision limitée, généralement d’environ 15 à 17 chiffres décimaux significatifs. De nombreuses fractions décimales, dont 0.1, n’ont pas de représentation exacte dans ce stockage. Par conséquent :

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

affiche 0.30000000000000004, puis 0.3. La très petite différence vient des approximations stockées. round(..., 2) arrondit le résultat à deux décimales pour l’affichage ; il ne change pas la façon dont les flottants stockent les valeurs. Garde le calcul d’origine jusqu’à la fin, puis arrondis le résultat affiché.

Un signe peut aussi être un opérateur. Le moins unaire change le signe d’une valeur : -7 signifie moins sept. Dans 5 - -3, le premier signe moins soustrait et le second donne moins trois, donc le résultat est 8. Distingue ce signe de l’exposant négatif dans un littéral comme 2.5e-3.

Une chaîne de caractères est une suite de caractères : lettres, chiffres, espaces, signes de ponctuation et autres symboles. Les guillemets indiquent à Python où cette suite commence et se termine. Les caractères à l’intérieur sont des données, même s’ils ressemblent à du code Python.

Choisis des guillemets assortis

Les guillemets simples et doubles créent le même type, str. 'Ada' et "Ada" contiennent tous deux les mêmes trois caractères. Commence et termine une chaîne avec le même type de guillemet.

Choisis les guillemets extérieurs de façon à faciliter l’écriture d’un guillemet intérieur :

print("It's late")
print('She said "hi"')

L’affichage est :

It's late
She said "hi"

Dans print('It's late'), l’apostrophe après It ferme la chaîne trop tôt. Python ne peut alors pas lire le reste de l’instruction. Des guillemets doubles à l’extérieur gardent l’apostrophe à l’intérieur du texte.

Utilise une séquence d’échappement

Une barre oblique inverse commence une séquence d’échappement. Chacune de ces séquences courantes représente un caractère :

Par exemple, print("Line 1\nLine 2") affiche deux lignes. La barre oblique inverse et le n dans le code représentent ensemble un saut de ligne, pas une lettre n visible. De même, print('It\'s late') affiche It's late : le guillemet échappé devient un caractère sans terminer la chaîne.

Pour afficher une barre oblique inverse littérale suivie d’une lettre, écris une double barre oblique inverse. print("A\\B") affiche A\B. La première barre oblique inverse indique que la suivante doit être un caractère.

Conserve les sauts de ligne ou aucun caractère

Les guillemets triples permettent à une chaîne de s’étendre sur plusieurs lignes physiques. Les sauts de ligne font partie de sa valeur :

print("""Line one
Line two""")

Cela affiche Line one et Line two sur des lignes distinctes. Les guillemets triples simples fonctionnent aussi. Les guillemets triples créent toujours une chaîne ; ils ne créent pas un commentaire #.

La chaîne vide, "", ne contient aucun caractère. Elle diffère de " ", qui contient un espace. Cet espace peut être difficile à voir à l’affichage, mais il reste une partie des données.

Distingue le texte d’une expression ou d’un nom

Compare ces instructions :

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

L’affichage est 3 + 4, puis 7, puis name, puis Ada. Les guillemets font du premier et du troisième argument du texte littéral. Sans guillemets, Python évalue un calcul ou recherche une variable.

Oublier les guillemets autour d’un message comme Hello pousse Python à rechercher un nom. Si Hello n’a pas été défini, print(Hello) lève une NameError. Écris print("Hello") lorsque tu veux ce mot.

Les chaînes peuvent contenir des caractères de nombreuses langues et des symboles comme "café", "naïve" et "°F". Des chiffres peuvent apparaître à leurs côtés : "Room 101" est entièrement du texte. Un caractère représentant un chiffre entre guillemets ne devient pas un entier.

Une variable est un nom qui désigne une valeur en mémoire. Une instruction d’affectation relie un nom à gauche de = à la valeur d’une expression située à droite.

Lis d’abord le côté droit

Dans age = 30, Python évalue 30, puis fait en sorte que age désigne cet entier. Le côté gauche doit être un emplacement valide pour affecter une valeur. 30 = age est une erreur de syntaxe : tu ne peux pas affecter une nouvelle valeur au littéral 30.

Le signe = signifie « affecter ». Il ne demande pas si deux valeurs sont égales. Le test d’égalité utilise ==. Lire l’affectation comme une opération qui va de droite à gauche rend compréhensibles des instructions comme x = x + 1 : utilise l’ancienne valeur de x à droite, calcule la nouvelle valeur, puis affecte-la à x à gauche.

Prenons un rectangle :

width = 4
height = 2.5
area = width * height
print(area)

Après la première ligne, width désigne 4. Après la deuxième, height désigne 2.5. Pour la troisième ligne, Python recherche les deux valeurs actuelles et évalue 4 * 2.5, ce qui produit 10.0. Il affecte ce résultat à area. La dernière ligne affiche 10.0.

L’affectation elle-même n’affiche pas la valeur. Utilise le nom dans un appel ultérieur à print() lorsque tu veux l’afficher.

Affecte une valeur avant d’utiliser un nom

Python suit l’ordre des instructions. Ce code échoue à la première ligne :

print(total)
total = 10

À ce stade, total n’a pas de valeur. L’affectation ultérieure ne peut pas fournir une valeur à une instruction antérieure. Déplace total = 10 avant print(total).

Une console peut conserver des noms issus d’essais précédents. Un programme enregistré doit fournir les affectations dont il a besoin dans son propre ordre d’exécution, afin que son résultat ne dépende pas de ce que tu as saisi auparavant.

Réaffecte une valeur à un nom existant

La réaffectation fait désigner une nouvelle valeur à un nom :

score = 10
score = 15

Maintenant, score vaut 15 ; l’ancienne valeur 10 n’est plus accessible par ce nom. Pour une mise à jour fondée sur l’ancienne valeur :

x = 3
x = x + 1

La deuxième ligne évalue 3 + 1, puis affecte 4 à x. Il n’y a aucune équation à résoudre et aucune contradiction.

Un type appartient à la valeur, pas définitivement au nom de variable. Python autorise temp = 3 suivi de temp = "three" ; après cela, type(temp) indique str. Garder un sens et un type attendu cohérents pour un nom rend généralement un programme plus facile à suivre.

Une valeur copiée ne crée pas de lien pour la suite

a = 5
b = a
a = 10
print(a, b)

Cela affiche 10 5. À l’instruction b = a, les deux noms désignent l’entier actuel 5. Réaffecter une valeur à a change la valeur que a désigne ; b continue de désigner 5. De même, stocker width * height enregistre son résultat, pas une formule qui se met à jour lorsque width change.

Une instruction peut affecter des valeurs à plusieurs noms. a = b = 0 donne aux deux noms la valeur 0. Dans x, y = 1, 2, les valeurs correspondent aux noms selon leur position : x vaut 1 et y vaut 2.

Un nom doit respecter la grammaire de Python et aider une personne à comprendre le programme. Ce sont deux critères distincts : Python peut accepter un nom qui rend malgré tout le code difficile à lire.

Suis les règles de nommage

Un nom de variable peut contenir des lettres, des chiffres et des caractères de soulignement. Il ne peut pas commencer par un chiffre, contenir un espace ou utiliser des signes de ponctuation comme un trait d’union.

Python accepte aussi les lettres d’autres alphabets. Les lettres anglaises sont un choix courant pour les identificateurs. Quelles que soient les lettres choisies, respecte toujours la même orthographe : age, Age et AGE sont trois noms différents. L’affectation age = 30 ne définit pas Age.

Distingue les mots-clés et les noms natifs

Un mot-clé est réservé à la grammaire de Python. Tu ne peux pas l’utiliser comme nom de variable. Les mots-clés réservés sont :

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

Tu n’as pas besoin de mémoriser cette liste avant d’écrire un programme. Pour l’instant, retiens qu’un nom comme class n’est pas disponible : class = 3 est une erreur de syntaxe. Les éditeurs affichent souvent les mots-clés dans une couleur particulière.

Les noms de fonctions natives, notamment print, input, int, str, type, sum et max, ne sont pas des mots-clés. Python t’autorise à leur affecter une valeur, mais cette affectation masque la fonction d’origine :

print = 5
print("hi")

La deuxième ligne tente d’appeler l’entier 5 et lève une TypeError. Choisis un nom qui décrit tes données, comme total, pour que la fonction native reste disponible. Redémarrer une console efface les remplacements accidentels effectués pendant les essais.

Écris les noms selon un style cohérent

PEP 8 recommande snake_case pour les noms de variables : des mots en minuscules reliés par des caractères de soulignement, comme dans hourly_rate et first_name. Le caractère de soulignement maintient ensemble les mots d’un nom sans utiliser d’espaces.

Une constante est une valeur que tu prévois de garder inchangée. Par convention, son nom s’écrit en majuscules :

SALES_TAX_RATE = 0.08

Python ne verrouille pas ce nom. Une affectation ultérieure peut le modifier ; les majuscules indiquent une intention au lecteur.

Indique le sens et les unités

hours_worked = 38 t’en dit plus que h = 38. Un nom comme distance_miles ou temp_f indique aussi l’unité, ce qui réduit le risque d’utiliser des miles comme s’il s’agissait de kilomètres ou des degrés Fahrenheit comme s’il s’agissait de degrés Celsius. Les noms courts comme x et y conviennent pour des coordonnées ou une formule brève dont le sens est déjà clair.

Évite les noms presque identiques comme total et totl. Une faute de frappe peut produire une NameError ou utiliser accidentellement une autre variable existante. PEP 8 déconseille aussi les noms d’une seule lettre l, O et I, qui peuvent ressembler à des chiffres. Quelques lettres supplémentaires peuvent rendre un calcul beaucoup plus facile à examiner.

Une mise à jour utilise la valeur actuelle d’une variable pour calculer sa valeur suivante. Suivre chaque mise à jour dans l’ordre permet de prévoir l’affichage et de trouver des erreurs de logique avant d’exécuter le programme.

Donne une valeur initiale avant de la mettre à jour

count = count + 1 ajoute un à l’ancien décompte. Ce changement est une incrémentation. Une variable qui recueille un total cumulé est un accumulateur ; donne-lui une valeur initiale comme total = 0 avant d’ajouter des quantités.

L’affectation augmentée combine une opération et une affectation. Pour les nombres, x += 3 a le même effet que x = x + 3. Les formes disponibles comprennent +=, -=, *=, /=, //=, %= et **=.

score = 10
score -= 3
score **= 2
print(score)

La soustraction donne à score la valeur 7. L’élévation à la puissance lui donne ensuite la valeur 49, qui est affichée. Sans l’affectation initiale, une mise à jour tenterait d’utiliser un nom non défini et lèverait une NameError.

L’opérateur choisi influe aussi sur le type. En partant de n = 7, n /= 2 produit le flottant 3.5. En repartant de n = 7, n //= 2 produit l’entier 3. Python n’a pas d’opérateur d’incrémentation ++ : x++ est invalide. Écrire ++x applique deux fois le plus unaire et ne met pas x à jour ; utilise x += 1.

Suis une instruction à la fois

Un tableau de suivi enregistre les valeurs des variables après chaque instruction. Écris une colonne par variable et une ligne par étape :

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

L’affichage est 65 25. Modifier price n’a pas répété la multiplication précédente. La variable total contenait la valeur calculée 60 ; ce n’était pas une formule de tableur liée à price. Seule sa propre mise à jour ultérieure lui a donné la valeur 65.

Pour un suivi à la main, évalue le côté droit à l’aide de la ligne immédiatement au-dessus, puis mets à jour le nom auquel la valeur est affectée. Laisse toutes les autres colonnes inchangées. Compare ta prévision avec l’affichage réel du programme.

Préserve les deux valeurs lors d’un échange

Supposons que a = 1 et b = 2. La tentative a = b suivie de b = a donne 2 2. La première affectation fait perdre l’accès à la valeur initiale de a par ce nom ; la deuxième ligne recopie donc la nouvelle valeur.

Une variable temporaire garde la valeur initiale accessible :

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

Cela affiche 2 1. Tu peux aussi écrire a, b = b, a. Python évalue les deux valeurs à droite avant d’affecter l’un ou l’autre des noms à gauche : les deux valeurs initiales sont donc disponibles pour l’échange. Suis la version avec la variable temporaire lorsque tu veux voir exactement où chaque valeur initiale est préservée.

Une expression s’évalue à une valeur. Elle peut être un littéral seul, une variable ou une combinaison comme 2 + 3. Le signe + est un opérateur ; les valeurs sur lesquelles il agit sont ses opérandes.

Choisis l’opérateur

Les opérateurs arithmétiques de Python fonctionnent ainsi :

Écris explicitement la multiplication avec *. Une notation mathématique comme 2x ne fonctionne pas comme une multiplication en Python. Écris 2 * x ou 2 * (x + 1). Avec x = 1, 2(x + 1) tente d’appeler l’entier 2 comme s’il s’agissait d’une fonction et lève une TypeError.

L’opérateur de puissance est **, pas ^. Par exemple, 7 ** 2 vaut 49, tandis que 7 ^ 2 vaut 5, car l’accent circonflexe effectue une autre opération. Un programme peut donc s’exécuter tout en calculant un résultat que tu ne souhaitais pas.

Prévois le type autant que le nombre

La division avec / donne un flottant pour des opérandes entiers, même lorsque la division est exacte : 6 / 2 vaut 3.0. Pour obtenir un nombre entier de groupes complets, utilise // : 6 // 2 vaut 3.

Avec deux opérandes entiers, l’addition, la soustraction, la multiplication, la division entière et le reste donnent des résultats entiers. Les puissances entières non négatives aussi : 2 ** 10 donne l’entier exact 1024. Un exposant négatif change cela : 2 ** -1 donne le flottant 0.5.

Dans un calcul arithmétique ordinaire avec un entier et un flottant, le calcul utilise des valeurs en virgule flottante. 3 + 4.0 donne 7.0 ; 7.0 // 2 donne 3.0. La division entière décrit comment le quotient est arrondi, sans garantir que son type soit toujours int.

Une puissance fractionnaire permet de calculer une racine d’un nombre positif. 4 ** 0.5 donne 2.0 et 2 ** 0.5 donne environ 1.4142135623730951.

Construis un calcul à partir de valeurs nommées

Une voiture parcourt 287 miles en utilisant 10,25 gallons :

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

La division calcule 28.0, donc l’affichage est Miles per gallon: 28.0. Les noms identifient les quantités et l’indication affichée précise l’unité du résultat. Multiplier 28.0 * 10.25 permet de retrouver 287 miles et de vérifier la division.

Un diviseur nul provoque une erreur avec /, // et %. Par exemple, 10 / 0 lève une ZeroDivisionError. Examine la variable utilisée comme diviseur lorsque cette erreur se produit.

Les espaces autour des opérateurs ne changent pas leur sens : 2+3 et 2 + 3 donnent tous deux 5. Les espaces autour de = et de la plupart des opérateurs facilitent la lecture des différentes parties. Ils ne peuvent pas remplacer un opérateur ; 2 x ne signifie toujours pas une multiplication.

Python ne calcule pas simplement une expression de gauche à droite. La priorité détermine les opérations effectuées en premier. Les parenthèses permettent de choisir un autre regroupement ou de rendre le regroupement voulu plus clair.

Applique les niveaux dans l’ordre

Pour les opérateurs présentés ici, utilise cet ordre :

1. Expressions entre parenthèses.
2. Puissances, **.
3. Signes unaires, comme le moins dans -x.
4. Multiplications et divisions : *, /, //, %.
5. Additions et soustractions : +, -.

Pour 3 + 4 * 2 ** 2, évalue 2 ** 2 pour obtenir 4. L’expression devient 3 + 4 * 4. La multiplication donne 16 et l’addition donne 19. Avec (3 + 4) * 2 ** 2, la somme entre parenthèses vaut 7 ; la puissance vaut 4 ; le produit vaut 28.

Les opérateurs au niveau de la multiplication et de la division ont la même priorité. Procède de gauche à droite : 8 / 2 * 4 signifie (8 / 2) * 4, ce qui donne 16.0. La multiplication ne passe pas avant la division. De même, 100 / 10 / 5 donne 2.0 et 10 - 4 - 3 donne 3.

Fais attention aux puissances et aux signes

Les puissances successives se regroupent de droite à gauche. 2 ** 3 ** 2 signifie 2 ** (3 ** 2). D’abord, 3 ** 2 donne 9 ; puis 2 ** 9 donne 512. Un regroupement depuis la gauche donnerait 64, un résultat différent.

Un signe moins placé devant une puissance est appliqué après celle-ci : -2 ** 2 signifie -(2 ** 2) et donne -4. Dans (-2) ** 2, les parenthèses font de moins deux la base, donc le résultat est 4. Un signe moins après ** peut appartenir à l’exposant : 2 ** -1 donne 0.5.

Traduis tout le regroupement d’une formule

Pour calculer une moyenne, il faut additionner les deux valeurs avant de diviser par deux :

average = (88 + 92) / 2

La somme vaut 180, puis la division donne 90.0. Sans parenthèses, 88 + 92 / 2 ne divise que 92 et donne 134.0.

Une barre de fraction regroupe aussi tout ce qui se trouve au-dessus et au-dessous. Un numérateur contenant a + b et un dénominateur contenant c + d deviennent (a + b) / (c + d). Omettre l’une ou l’autre paire de parenthèses peut changer les termes qui sont divisés.

Le même problème apparaît dans une conversion de température :

celsius = (98.6 - 32) * 5 / 9

La soustraction donne 66.6, la multiplication donne 333.0 et la division donne 37.0. Sans ce regroupement, 98.6 - 32 * 5 / 9 donne 80.82222222222222.

Utilise les bons signes de regroupement

Les parenthèses rondes regroupent une expression. Les crochets et les accolades ont d’autres sens en Python. Par exemple, [2 + 3] * 4 produit [5, 5, 5, 5], et non 20.

Des parenthèses autour d’une opération qui serait de toute façon effectuée en premier ne changent pas le résultat : (2 * 3) + 1 et 2 * 3 + 1 donnent tous deux 7. Des parenthèses qui modifient le regroupement peuvent changer la valeur : 2 * (3 + 1) donne 8. Ajoute des parenthèses là où elles rendent le sens du calcul plus facile à comprendre.

La division entière et le reste répondent à deux questions liées : combien de groupes entiers peuvent être formés et que reste-t-il après avoir pris ces groupes ? Pour des quantités entières non négatives, cette paire est utile pour le temps, l’argent, les emballages et les chiffres.

Trouve ensemble le quotient et le reste

17 // 5 donne 3, le nombre de groupes complets de cinq. 17 % 5 donne 2, la quantité restante. Les deux résultats permettent de reconstituer la quantité de départ :

print((17 // 5) * 5 + 17 % 5)

L’expression donne 17 : trois groupes de cinq plus deux. Plus généralement, pour des entiers et un diviseur non nul, (a // b) * b + a % b est égal à a. Utilise cette relation pour vérifier les deux réponses.

Répartis des quantités concrètes

Pour 135 minutes :

hours = 135 // 60
minutes = 135 % 60

Il y a 2 heures entières et 15 minutes restantes. Le diviseur est 60, car une heure contient 60 minutes. La division avec / donne 2.25, qui exprime des heures fractionnaires ; elle ne donne pas séparément les minutes restantes.

La même structure fonctionne avec une taille de groupe différente :

Le nombre de boîtes est celui des boîtes complètes. Si tu as aussi besoin d’un contenant pour les œufs restants, c’est une question différente de celle du nombre de groupes complets qu’on peut former.

Utilise la valeur de position et la parité

Pour un entier positif, la division par dix permet de séparer son dernier chiffre. 1234 % 10 donne 4 et 1234 // 10 donne 123. Recombiner 123 * 10 + 4 permet de retrouver 1234.

Pour tout entier n, n % 2 vaut 0 s’il est pair et 1 s’il est impair. Cela fonctionne aussi pour les nombres négatifs : -7 % 2 vaut 1. Pour des entiers et un diviseur positif b, le reste est compris entre 0 et b - 1 inclus.

Comprends la division avec des nombres négatifs

La division entière arrondit vers l’infini négatif, pas vers zéro. Comme moins sept divisé par deux vaut -3,5, -7 // 2 donne -4. Le reste vaut alors 1, car -4 * 2 + 1 est égal à -7.

Un reste non nul a le signe du diviseur. Avec un diviseur négatif, 7 % -2 donne -1 et 7 // -2 donne -4. Ces résultats permettent toujours de reconstituer la valeur initiale : -4 * -2 + -1 vaut 7.

C’est différent de la conversion d’un quotient avec int() : int(-7 / 2) donne -3, car la conversion tronque vers zéro.

Les deux opérateurs acceptent aussi les flottants. 7.5 // 2 vaut 3.0 et 7.5 % 2 vaut 1.5. Ils ont le même niveau de priorité que * et /, donc 5 * 3 + 17 % 5 donne 17. L’opérateur % signifie ici le reste, pas le pourcentage : calcule 8 % d’un prix avec price * 0.08 ou price * 8 / 100.

Le symbole d’un opérateur ne représente qu’une partie de son sens. Python utilise aussi les types de ses opérandes. Les opérateurs + et * fonctionnent avec les chaînes, mais ils effectuent alors des opérations sur le texte.

Assemble des chaînes avec le signe plus

La concaténation ajoute une chaîne à la fin d’une autre :

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

Ces lignes affichent abcd, HelloAda et Hello Ada. La concaténation n’ajoute pas d’espace d’elle-même. L’espace dans le troisième résultat vient du dernier caractère de "Hello ".

Les caractères représentant des chiffres suivent la même règle : "5" + "3" donne la chaîne "53". Sans guillemets, 5 + 3 donne l’entier 8. Choisis des valeurs numériques pour les calculs et des chaînes pour le texte.

Répète une chaîne avec la multiplication

Une chaîne multipliée par un entier répète ses caractères. "3" * 2 donne "33", tandis que 3 * 2 donne 6. Le nombre de répétitions peut être placé d’un côté ou de l’autre : 3 * "ab" donne "ababab". Répéter zéro fois donne la chaîne vide, donc "ab" * 0 vaut "".

Le nombre de répétitions doit être un entier. "ab" * 2.5 lève une TypeError, tout comme "ab" * "cd". Cette opération ne permet pas d’obtenir un nombre fractionnaire de copies.

Combine les opérations dans l’ordre

La multiplication est aussi prioritaire sur l’addition dans ces expressions :

print("-" * 4 + "Menu" + "-" * 4)

D’abord, chaque répétition crée "----". Ensuite, les additions assemblent les trois chaînes et produisent ----Menu----. L’ordre des assemblages préserve l’ordre de leurs caractères.

Pour un calcul qui devient une partie d’une chaîne :

print("7" + str(3 * 2))

Le calcul interne donne l’entier 6. str(6) crée la chaîne "6". Enfin, la concaténation produit "76". Elle ne produit pas 13, car le dernier + a deux chaînes pour opérandes.

Résous volontairement les incompatibilités de types

"Age: " + 30 lève une TypeError. Convertis l’entier avant de concaténer :

print("Age: " + str(30))

Cela produit Age: 30. Tu peux aussi utiliser print("Age:", 30), qui affiche les deux valeurs avec un espace entre elles. C’est le comportement de print() avec des arguments distincts, pas une addition de texte.

Les entiers et les flottants peuvent être mélangés dans les calculs arithmétiques ordinaires : 2 * 3.0 donne le flottant 6.0. Python ne transforme pas de la même façon une chaîne numérique en nombre pendant une opération +. Si tu dois calculer avec "30", convertis-la d’abord en type numérique.

La soustraction ne fonctionne pas sur ces opérandes de type chaîne. "10" - 3 lève une TypeError, même si les caractères 10 pourraient représenter un nombre. Pour prévoir le résultat d’une expression de types mixtes, identifie le type de chaque opérande, évalue les opérations prioritaires, puis vérifie à nouveau les types à l’opération suivante. Une conversion peut changer la règle que l’opérateur suivant applique.

La conversion de type crée une valeur d’un type différent. Les fonctions int(), float() et str() permettent de choisir la forme nécessaire à l’opération suivante.

Conserve le résultat converti

x = "42"
int(x)
print(type(x))

Cela affiche toujours <class 'str'>. La conversion a créé un entier, mais aucune affectation ne l’a conservé. Écris x = int(x) pour que x désigne cet entier, ou affecte-le à un autre nom si tu veux conserver les deux formes.

Choisis une conversion numérique

int() accepte une chaîne représentant un entier, éventuellement précédé d’un signe et entouré d’espaces. int("42"), int("-12") et int(" 42 ") produisent 42, -12 et 42.

Un point décimal dans une chaîne empêche sa conversion directe en entier. int("3.5") et int("4.0") lèvent une ValueError ; int("abc") et int("") aussi. Le fait que 4,0 soit mathématiquement entier ne fait pas de "4.0" une chaîne écrite sous forme d’entier.

float() accepte le texte décimal et la notation avec exposant. float("3.5") donne 3.5, float("3") donne 3.0 et float("1e3") donne 1000.0. Il convertit aussi les entiers : float(7) donne 7.0. Une virgule décimale provoque un échec : float("3,5") lève une ValueError.

Tronque ou arrondis volontairement

Convertir un flottant en int supprime sa partie fractionnaire vers zéro. int(3.99) donne 3 et int(-3.99) donne -3. Cette conversion ne choisit pas l’entier le plus proche. Pour convertir un texte décimal puis le tronquer, utilise int(float("3.5")), qui donne 3.

round() choisit une valeur parmi les plus proches. round(3.7) donne l’entier 4 ; round(3.14159, 2) donne le flottant 3.14. Le deuxième argument fixe le nombre de décimales.

À mi-chemin exact, Python choisit le voisin pair : round(2.5) donne 2, tandis que round(3.5) donne 4. Les fractions décimales stockées comme flottants peuvent ne pas être exactement à mi-chemin. round(2.675, 2) donne 2.67 à cause de sa représentation binaire.

Ces opérations répondent à des questions différentes. Choisis celle qui correspond au résultat voulu, surtout lorsque des valeurs négatives sont possibles.

Convertis en texte pour assembler

str(42) produit "42" et str(3.0) produit "3.0". Après conversion, + assemble leurs caractères :

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

Les résultats affichés sont 73, 10, 73 et 10.0. Les conversions déterminent si le dernier + reçoit du texte ou des nombres.

Une ValueError indique un contenu inadapté à une conversion, comme dans int("abc"). Une TypeError indique une opération incompatible avec ses opérandes, comme dans "5" + 5. Utilise cette différence pour décider si tu dois examiner le texte saisi ou modifier l’opération.

print() affiche des valeurs destinées à être lues. Ses arguments sont les valeurs ou expressions placées entre ses parenthèses. Des virgules séparent les arguments ; Python les évalue avant d’en afficher les résultats.

Affiche des valeurs avec des indications utiles

print("Total:", 5)
print(3 + 4)
print("3 + 4")

Les lignes affichent Total: 5, 7 et 3 + 4. Une indication précise au lecteur ce que signifie une valeur. Un calcul sans guillemets est évalué ; une expression entre guillemets est affichée comme du texte.

Par défaut, print() place un espace entre les arguments et termine par un saut de ligne. Il convertit chaque valeur pour l’affichage, donc print("Total:", 5) peut mélanger du texte et un entier sans appel explicite à str().

Compare avec print("Total:" + str(5)), qui affiche Total:5. Ici, + construit une chaîne avant que print() la reçoive. La concaténation ne fournit pas d’espace automatiquement et il n’y a qu’un seul argument à afficher.

Définis le séparateur

L’argument nommé sep définit le texte placé entre les arguments :

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

L’affichage est :

a-b
1, 2, 3
A12

Utilise le nom sep. Écrire print("a", "b", "-") fournit une troisième valeur, donc le résultat est a b -. Un séparateur vide assemble directement les arguments affichés ; il ne supprime pas les espaces déjà présents dans leurs chaînes.

Définis la fin de ligne

L’argument nommé end modifie ce qui suit la dernière valeur. Par défaut, c’est un saut de ligne. Une fin vide garde l’affichage suivant sur la même ligne :

print("a", end="")
print("b")

Cela affiche ab sur une ligne. Tu peux associer un signe de ponctuation et un saut de ligne :

print("Hello,", "Ada", end="!\n")

L’affichage est Hello, Ada!, suivi d’un saut de ligne. sep s’applique entre les arguments d’un même appel ; end s’applique après le dernier argument de cet appel. Ils contrôlent des emplacements différents.

Ajoute des sauts de ligne et choisis la précision affichée

Appeler print() sans argument affiche une ligne vide. Un \n dans une chaîne crée un saut de ligne à l’intérieur de celle-ci, comme dans print("Line 1\nLine 2"). Du texte répété peut former un séparateur : print("=" * 20) affiche vingt signes égal.

Python affiche un flottant sous une forme courte qui représente sa valeur stockée. print(1 / 3) affiche 0.3333333333333333. Pour afficher une valeur arrondie, calcule-la d’abord dans l’appel : print(round(1 / 3, 2)) affiche 0.33.

L’arrondi ne garantit pas un nombre fixe de décimales visibles. round(2.50, 2) s’affiche sous la forme 2.5, car le flottant ne stocke pas les zéros finaux comme une instruction d’affichage. Utilise le résultat exactement comme Python le produit lorsque tu vérifies un programme.

input() affiche une invite, attend qu’une personne saisisse du texte et appuie sur Entrée, puis renvoie le texte saisi sous forme de chaîne, sans la touche Entrée. Un programme court complet lit les données nécessaires, les traite et affiche un résultat.

Lis du texte et convertis les nombres

name = input("What is your name? ")
print("Hello", name)

L’espace à la fin de l’invite sépare la réponse saisie de la question. La variable stocke le texte comme du texte, même lorsque l’utilisateur saisit des chiffres. Saisir 30 dans input() produit "30", et non l’entier 30.

Choisis une conversion avant de calculer :

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

L’appel interne à input() s’exécute en premier. Si l’utilisateur saisit 30, il renvoie "30" ; int() convertit cette chaîne en 30 ; l’affectation conserve l’entier. L’addition produit ensuite 31.

Utilise float(input(...)) lorsque les valeurs fractionnaires sont autorisées. Une invite doit indiquer quel type de réponse est attendu. Saisir 2.5 ou thirty pour une conversion avec int() lève une ValueError. Saisir 98,6 pour une conversion avec float() échoue aussi ; le séparateur décimal doit être un point.

Une conversion oubliée ne lève pas toujours une erreur. Si deux appels à input reçoivent 5 et 3, leurs valeurs non converties s’additionnent comme des chaînes et produisent 53. Les deux opérandes ont un type qui accepte +, mais ce n’est pas la bonne opération pour additionner des quantités.

Examine un calcul complet

Le schéma entrée–traitement–sortie rend les étapes principales faciles à examiner :

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

Avec la saisie 98.6, le programme lit le flottant 98.6. Il soustrait 32 pour obtenir 66.6, multiplie par 5 pour obtenir 333.0 et divise par 9 pour obtenir 37.0. La ligne affichée est 98.6 °F is 37.0 °C. La saisie 50 devient 50.0, donc la ligne est 50.0 °F is 10.0 °C.

Voici un programme avec des données entières :

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

La saisie 135 produit Hours: 2 Minutes: 15. Les indications conviennent pour zéro, un et des résultats plus grands sans changer la formulation. Les deux lignes de traitement utilisent le même total initial ; affecter une valeur à hours ne retire rien de total_minutes.

Teste des valeurs ordinaires et des valeurs limites

Choisis des saisies dont tu peux calculer les réponses à la main. Pour le programme de température, 32 devrait produire 0.0 °C et 212 devrait produire 100.0 °C. Pour les minutes, teste 0, 59 et 60 : ces valeurs vérifient la valeur de départ et le passage de zéro heure complète à une heure complète.

Teste aussi une valeur courante comme 135. Compare les indications exactes, les espacements, les résultats numériques et les types avec ta prévision. Si le code s’exécute mais que le résultat est incorrect, suis les valeurs stockées et l’ordre des opérations. Si une conversion échoue, examine le texte saisi et le type demandé par ton invite.