Utiliser les variables et les instructions élémentaires

La programmation consiste à donner des instructions précises à un ordinateur pour qu'il réalise une tâche. Imagine que tu donnes une recette de cuisine très détaillée à quelqu'un : chaque étape doit être claire et sans ambiguïté. C'est pareil avec un ordinateur !

Un programme est une suite d'instructions écrites dans un langage de programmation, par exemple Python. L'ordinateur exécute ces instructions dans l'ordre pour atteindre un objectif.

Avant d'écrire un programme, on commence souvent par un algorithme. Un algorithme est une description étape par étape de la solution à un problème, sans se soucier du langage de programmation. C'est un peu comme le plan d'une maison avant de commencer à la construire. Le code est ensuite la traduction de cet algorithme dans un langage de programmation spécifique (ici, Python).

En programmation, une variable est un conteneur qui permet de stocker des informations (des données). Tu peux l'imaginer comme une boîte à laquelle tu donnes un nom. Cette boîte peut contenir différentes choses, et son contenu peut changer au cours du programme.

Le rôle principal d'une variable est de stocker des données dans la mémoire de l'ordinateur. Quand tu utilises une variable, l'ordinateur va chercher ou modifier la valeur qu'elle contient à un endroit précis de sa mémoire.

Pour nommer une variable, il y a quelques règles importantes à respecter en Python :

• Un nom de variable doit commencer par une lettre (minuscule de préférence) ou un underscore (_).
• Il ne peut contenir que des lettres, des chiffres et des underscores.
• Il ne doit pas contenir d'espaces ni de caractères spéciaux (comme é, &, $).
• Il ne doit pas être un mot réservé par Python (comme print, if, for).
• Les noms doivent être explicites : age_utilisateur est mieux que a pour stocker l'âge d'un utilisateur.

Exemples de noms valides : mon_age, nombre1, _total. Exemples de noms invalides : 1nombre, mon age, class.

En Python, tu n'as pas besoin de "déclarer" une variable avant de l'utiliser comme dans d'autres langages. La première fois que tu donnes une valeur à une variable, elle est automatiquement créée. C'est ce qu'on appelle l'affectation.

L'opérateur d'affectation est le signe égal (=).

# C'est la première affectation, la variable 'age' est créée et initialisée à 16
age = 16

Ici, la variable age est initialisée avec la valeur 16. L'ordinateur réserve un espace en mémoire, le nomme age et y place la valeur 16.

Tu peux ensuite mettre à jour la valeur d'une variable à tout moment :

age = 16       # Initialisation
print(age)     # Affiche 16

age = 17       # Mise à jour : la valeur 16 est remplacée par 17
print(age)     # Affiche 17

age = age + 1  # On utilise l'ancienne valeur pour calculer la nouvelle (17 + 1 = 18)
print(age)     # Affiche 18

Une variable ne peut contenir qu'une seule valeur à la fois. Chaque nouvelle affectation écrase l'ancienne valeur.

Les nombres entiers (type int pour integer) sont des nombres sans partie décimale, qu'ils soient positifs, négatifs ou zéro.

Exemples : 5, -10, 0, 1000.

Tu peux effectuer des opérations arithmétiques de base avec les entiers :

• Addition : +
• Soustraction : -
• Multiplication : *
• Division : / (attention, le résultat est toujours un nombre décimal, même si la division "tombe juste")

a = 10
b = 3
somme = a + b      # 13
difference = a - b # 7
produit = a * b    # 30
division = a / b   # 3.3333... (un float !)

La priorité des opérations est la même qu'en mathématiques : la multiplication et la division sont effectuées avant l'addition et la soustraction. Les parenthèses () peuvent être utilisées pour modifier cette priorité.

resultat1 = 2 + 3 * 4   # 3 * 4 = 12, puis 2 + 12 = 14
resultat2 = (2 + 3) * 4 # 2 + 3 = 5, puis 5 * 4 = 20

Les nombres décimaux (type float pour floating-point number) sont des nombres qui ont une partie fractionnaire, c'est-à-dire avec une virgule (en Python, on utilise un point . pour la partie décimale).

Exemples : 3.14, -0.5, 10.0 (même si c'est un entier, 10.0 est considéré comme un float).

La représentation des décimaux en informatique peut parfois être source de petites imprécisions. Par exemple, 0.1 + 0.2 ne donne pas exactement 0.3 mais un nombre très proche comme 0.30000000000000004 à cause de la façon dont les ordinateurs stockent ces nombres. C'est important à savoir pour les calculs très précis.

prix_unitaire = 12.50
quantite = 3
total = prix_unitaire * quantite # 37.5

Une chaîne de caractères (type str pour string) est une séquence de caractères (lettres, chiffres, symboles, espaces). C'est le type utilisé pour le texte.

Exemples : "Bonjour", 'Python', "123", "Ceci est une phrase.".

Les chaînes de caractères doivent être délimitées par des guillemets simples (') ou doubles ("). L'important est d'utiliser la même paire.

message1 = "Salut le monde !"
message2 = 'J\'apprends Python.' # Utilisation de l'apostrophe à l'intérieur avec les guillemets simples

Tu peux joindre plusieurs chaînes de caractères ensemble (c'est ce qu'on appelle la concaténation) avec l'opérateur +.

prenom = "Alice"
nom = "Dupont"
nom_complet = prenom + " " + nom # "Alice Dupont"

Le type booléen (type bool) est le plus simple. Il ne peut prendre que deux valeurs : True (Vrai) ou False (Faux). Ces valeurs sont très importantes pour prendre des décisions dans un programme.

est_majeur = True
a_permis = False

Les booléens sont très utilisés dans les conditions (nous les verrons plus tard) pour contrôler le flux d'exécution du programme.

Tu peux combiner des booléens avec des opérateurs logiques :

• AND (et) : Le résultat est True si les deux conditions sont True.
• OR (ou) : Le résultat est True si au moins une des conditions est True.
• NOT (non) : Inverse la valeur booléenne (True devient False, et False devient True).

condition1 = True
condition2 = False

print(condition1 and condition2) # False
print(condition1 or condition2)  # True
print(not condition1)            # False

La fonction print() est l'instruction la plus courante pour afficher des informations à l'écran (dans la console).

Pour afficher du texte, tu le places entre guillemets :

print("Bonjour, bienvenue en Seconde !")

Tu peux aussi afficher la valeur d'une variable :

nom = "Python"
print(nom)  # Affiche Python

Pour afficher du texte et des variables ensemble, tu peux les séparer par des virgules (,) dans la fonction print(). Python ajoutera automatiquement un espace entre chaque élément.

age = 16
print("Tu as", age, "ans.") # Affiche : Tu as 16 ans.

temperature = 20.5
unite = "degrés Celsius"
print("Il fait", temperature, unite, "aujourd'hui.") # Affiche : Il fait 20.5 degrés Celsius aujourd'hui.

On peut aussi utiliser les f-strings (chaînes formatées) pour plus de flexibilité (plus avancé) : print(f"Tu as {age} ans.")

La fonction input() permet de récupérer une saisie utilisateur depuis le clavier. Le programme s'arrête et attend que l'utilisateur tape quelque chose et appuie sur Entrée.

prenom = input("Quel est ton prénom ? ")
print("Bonjour", prenom)

Le texte que tu passes en argument à input() est affiché comme une question pour l'utilisateur.

CRITIQUE : La fonction input() renvoie toujours la saisie de l'utilisateur sous forme de chaîne de caractères (str), même si l'utilisateur entre un nombre. C'est une source fréquente d'erreurs si tu ne le sais pas !

annee_naissance = input("En quelle année es-tu né(e) ? ")
# Si l'utilisateur tape "2007", annee_naissance sera la chaîne de caractères "2007"
type_variable = type(annee_naissance)
print(type_variable) # Affiche <class 'str'>

Étant donné que input() renvoie toujours une chaîne de caractères, il y a souvent une nécessité de conversion si tu veux effectuer des opérations mathématiques avec la valeur saisie par l'utilisateur.

Python propose des fonctions pour convertir les types :

• int(valeur) : Convertit valeur en entier.
• float(valeur) : Convertit valeur en nombre décimal.
• str(valeur) : Convertit valeur en chaîne de caractères.

annee_naissance_str = input("En quelle année es-tu né(e) ? ") # Saisie: "2007" (str)
annee_naissance_int = int(annee_naissance_str)               # Conversion: 2007 (int)

age = 2024 - annee_naissance_int
print("Tu as environ", age, "ans.")

Attention aux erreurs de conversion ! Si tu essaies de convertir une chaîne de caractères qui ne représente pas un nombre valide en int ou float, Python générera une erreur (ValueError).

# exemple_erreur = int("Bonjour") # Ceci provoquerait une erreur !

Nous avons déjà vu les opérateurs de base. En voici d'autres, très utiles :

• La division entière (//) donne le quotient de la division euclidienne (le nombre de fois que le diviseur "rentre" dans le dividende, sans la partie décimale).
• Le modulo (%) donne le reste de la division euclidienne. C'est très utile pour savoir si un nombre est pair (reste 0 lorsqu'il est divisé par 2) ou pour des calculs cycliques.
• La puissance (**) permet de calculer un nombre élevé à une certaine puissance.

print(17 // 5) # Affiche 3 (17 = 3 * 5 + 2)
print(17 % 5)  # Affiche 2 (le reste de la division)
print(2 ** 3)  # Affiche 8 (2 * 2 * 2)

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs. Ils renvoient toujours un résultat de type booléen (True ou False).

==Attention à ne pas confondre l'opérateur d'affectation (=) et l'opérateur d'égalité (<mark>). C'est une erreur très courante chez les débutants.

Une expression est une combinaison de variables, de valeurs et d'opérateurs qui peut être évaluée pour produire un résultat.

Exemples d'expressions :

• age + 5
• prix_ht * 1.20
• "Bonjour" + nom
• x > 10 and y < 20

L'ordre d'évaluation des opérateurs suit des règles de priorité similaires aux mathématiques :

1. Parenthèses () (le plus prioritaire)
2. Puissance **
3. Multiplication *, Division /, Division entière //, Modulo % (de gauche à droite)
4. Addition +, Soustraction - (de gauche à droite)
5. Opérateurs de comparaison ==, !=, >, <, >=, <=
6. Opérateurs logiques not, and, or (le moins prioritaire)

resultat = 5 + 3 * 2 ** 2 - (10 / 5)
# 1. 2 ** 2 = 4
# 2. 3 * 4 = 12
# 3. 10 / 5 = 2.0 (float)
# 4. 5 + 12 = 17
# 5. 17 - 2.0 = 15.0
print(resultat) # Affiche 15.0

Il est toujours préférable d'utiliser des parenthèses () pour rendre l'expression plus lisible et éviter les ambiguïtés, même si l'ordre de priorité par défaut est correct.

Avant de coder, prends toujours le temps de définir les étapes de ton programme. C'est la phase d'algorithmique.

Exemple : Calculer l'aire d'un rectangle.

Algorithme :

1. Entrée : Demander à l'utilisateur la longueur du rectangle.
2. Entrée : Demander à l'utilisateur la largeur du rectangle.
3. Traitement : Calculer l'aire en multipliant la longueur par la largeur.
4. Sortie : Afficher le résultat de l'aire.

Cet algorithme utilise des variables pour stocker la longueur, la largeur et l'aire. Il suit le schéma classique Entrée, Traitement, Sortie (ETS).

La traduction consiste à utiliser les instructions vues (variables, input(), print(), opérateurs) et à respecter la syntaxe de Python.

Pour l'exemple du rectangle :

# 1. Entrée : Demander la longueur
longueur_str = input("Entrez la longueur du rectangle : ")
longueur = float(longueur_str) # Conversion en float car la longueur peut être décimale

# 2. Entrée : Demander la largeur
largeur_str = input("Entrez la largeur du rectangle : ")
largeur = float(largeur_str) # Conversion en float

# 3. Traitement : Calculer l'aire
aire = longueur * largeur

# 4. Sortie : Afficher le résultat
print("L'aire du rectangle est :", aire)

Après avoir écrit ton programme, il est crucial de le tester. Exécute-le avec différentes valeurs pour vérifier qu'il fonctionne comme prévu.

Le débogage est le processus qui consiste à trouver et corriger les erreurs (les "bugs") dans ton code.

Il existe deux types principaux d'erreurs :

1. Erreurs de syntaxe : Ce sont des fautes de "grammaire" du langage. Python ne comprend pas ce que tu as écrit et arrête l'exécution du programme. Par exemple, oublier une parenthèse ou un guillemet. Python affiche des messages d'erreur qui t'indiquent la ligne où l'erreur a eu lieu (SyntaxError).
2. Erreurs logiques : Le programme s'exécute, mais il ne fait pas ce que tu attends. Par exemple, tu as utilisé l'addition au lieu de la multiplication. Python ne détecte pas ces erreurs, c'est à toi de les trouver en testant et en vérifiant les résultats.

Stratégies de correction :

• Lis attentivement les messages d'erreur Python : Ils sont souvent très utiles pour localiser le problème. Cherche la ligne indiquée.
• Vérifie ta syntaxe : Parentheses, guillemets, noms de variables corrects.
• Imprime les valeurs des variables : Insère des print() temporaires dans ton code pour voir ce que contiennent tes variables à différents moments. Cela t'aide à comprendre où la logique déraille.
• Exécute ton code pas à pas (avec un débogueur si disponible) : C'est plus avancé, mais très puissant pour suivre l'exécution ligne par ligne.
• Simplifie le problème : Si ton programme est complexe, essaie de le réduire à la partie qui pose problème et de déboguer cette petite partie.

Le débogage fait partie intégrante de la programmation. Ne te décourage pas, c'est en faisant des erreurs qu'on apprend le mieux !