2. Vos premiers programmes Python

Dans le chapitre 1, vous avez appris à installer Python, à utiliser le shell interactif (REPL) et à exécuter de simples fichiers de script. Vous avez également eu un premier aperçu des erreurs et des tracebacks. Il est maintenant temps d’écrire vos premiers vrais programmes Python — des programmes qui affichent des informations, acceptent des entrées de la part des utilisateurs et produisent des résultats significatifs.

Ce chapitre présente les éléments de base que vous utiliserez dans presque tous les programmes Python que vous écrirez : la fonction print() pour afficher des sorties, les commentaires pour documenter votre code, les variables pour stocker des données, et la fonction input() pour obtenir des informations auprès des utilisateurs. À la fin de ce chapitre, vous serez capable de créer des programmes interactifs simples mais complets qui suivent le modèle classique input-process-output.

2.1) Afficher du texte avec la fonction print()

La fonction print() est l’un des outils les plus essentiels de Python. Elle affiche du texte (et d’autres informations) à l’écran, ce qui permet à vos programmes de communiquer avec les utilisateurs. Vous avez déjà vu print() rapidement dans le chapitre 1, mais nous allons maintenant l’examiner en détail.

2.1.1) Affichage de base

Au plus simple, print() affiche du texte entouré de guillemets. Créons un fichier de script pour voir comment cela fonctionne :

# hello.py
print("Hello, World!")

Lorsque vous exécutez ce script, Python affiche :

Hello, World!

Le texte à l’intérieur des guillemets — "Hello, World!" — est appelé une string. Une string est une séquence de caractères (lettres, chiffres, symboles, espaces) que Python traite comme du texte. Nous explorerons les strings en bien plus de détail au chapitre 5, mais pour l’instant, considérez-les comme la manière de représenter du texte en Python.

Vous pouvez afficher n’importe quel texte en le plaçant entre guillemets :

# greetings.py
print("Welcome to Python programming!")
print("This is your first real program.")
print("Python makes programming fun and accessible.")

Output:

Welcome to Python programming!
This is your first real program.
Python makes programming fun and accessible.

Remarquez que chaque instruction print() produit une sortie sur une ligne séparée. Python ajoute automatiquement un saut de ligne (newline) après chaque appel à print(), ce qui déplace le curseur à la ligne suivante.

2.1.2) Afficher plusieurs éléments

La fonction print() peut afficher plusieurs éléments en un seul appel en les séparant par des virgules :

# multiple_items.py
print("Python", "is", "awesome!")
print("I", "am", "learning", "to", "code")

Output:

Python is awesome!
I am learning to code

Lorsque vous séparez les éléments par des virgules, print() insère automatiquement un espace entre eux. C’est pratique pour combiner plusieurs morceaux de texte sans avoir à ajouter manuellement des espaces.

Vous pouvez aussi mélanger différents types de données. Par exemple, vous pouvez afficher à la fois du texte et des nombres :

# mixed_output.py
print("The answer is", 42)
print("Python version", 3.12, "is powerful")

Output:

The answer is 42
Python version 3.12 is powerful

Python convertit automatiquement les nombres en texte lorsqu’il les affiche, donc vous n’avez pas besoin de vous soucier pour l’instant des détails techniques. Nous en apprendrons davantage sur les différents types de données au chapitre 3.

2.1.3) Guillemets simples vs doubles

Python accepte à la fois les guillemets simples (') et les guillemets doubles (") pour les strings. Ils sont totalement interchangeables pour du texte simple :

# quotes.py
print("This uses double quotes")
print('This uses single quotes')
print("Both work exactly the same way")

Output:

This uses double quotes
This uses single quotes
Both work exactly the same way

Cependant, les guillemets deviennent importants lorsque votre texte contient des apostrophes ou des guillemets. Si votre texte contient une apostrophe (qui est le même caractère qu’un guillemet simple), utilisez des guillemets doubles pour l’entourer :

# apostrophes.py
print("It's a beautiful day!")
print("Python's syntax is clean")

Output:

It's a beautiful day!
Python's syntax is clean

Si vous essayiez d’utiliser des guillemets simples ici, Python serait perturbé :

# This causes an error:
print('It's a beautiful day!')  # Error! Python sees three separate quotes

L’erreur se produit parce que Python voit l’apostrophe dans "It's" comme la fin de la string, laissant "s a beautiful day!" comme du code invalide.

De la même façon, si votre texte contient des guillemets doubles, utilisez des guillemets simples pour l’entourer :

# quotations.py
print('She said, "Hello!"')
print('The book is called "Python Basics"')

Output:

She said, "Hello!"
The book is called "Python Basics"

Recommandation pratique : choisissez un style (guillemets simples ou doubles) et utilisez-le de manière cohérente dans tout votre code. La plupart des programmeurs Python préfèrent les guillemets doubles pour les strings ordinaires, mais l’un ou l’autre convient. Ne changez de style que lorsque votre texte contient le type de guillemet que vous utilisez habituellement.

2.1.4) Afficher des lignes vides

Il arrive que vous vouliez ajouter des lignes vides à votre sortie pour la rendre plus lisible. Vous pouvez le faire en appelant print() sans argument :

# spacing.py
print("First section of output")
print("More information here")
print()  # Empty line
print("Second section of output")
print("This is separated from the first section")

Output:

First section of output
More information here
 
Second section of output
This is separated from the first section

L’appel print() vide crée une ligne blanche, ce qui rend la sortie plus facile à lire en séparant visuellement différentes sections.

2.1.5) Caractères spéciaux dans les strings

Parfois, vous devez inclure dans votre sortie des caractères spéciaux que vous ne pouvez pas taper directement ou qui ont une signification particulière en Python. Par exemple, comment créer un saut de ligne au milieu d’une string ? Ou insérer une tabulation pour l’alignement ? Python fournit des séquences d’échappement — des combinaisons spéciales de deux caractères qui commencent par un antislash (\) — pour représenter ces caractères.

Ces séquences d’échappement sont particulièrement utiles lorsque vous devez formater la sortie de façon précise — créer des messages multilignes, aligner des colonnes de données, ou travailler avec des chemins de fichiers sous Windows. Vous utiliserez \n fréquemment à mesure que vous écrirez plus de programmes.

La séquence d’échappement la plus courante est \n, qui représente un saut de ligne :

# newlines.py
print("First line\nSecond line\nThird line")

Output:

First line
Second line
Third line

Le \n indique à Python de passer à une nouvelle ligne à cet endroit dans la string. C’est utile lorsque vous voulez créer plusieurs lignes de sortie avec une seule instruction print().

Une autre séquence d’échappement utile est \t, qui représente une tabulation (espacement horizontal) :

# tabs.py
print("Name:\tJohn")
print("Age:\t25")
print("City:\tNew York")

Output:

Name:	John
Age:	25
City:	New York

Le \t crée un espacement régulier, alignant les valeurs comme dans une colonne.

Si vous devez inclure un véritable antislash dans votre sortie, utilisez \\ :

# backslash.py
print("The file path is C:\\Users\\Documents")

Output:

The file path is C:\Users\Documents

Nous explorerons les séquences d’échappement et la gestion des strings en bien plus de détail au chapitre 5. Pour l’instant, retenez simplement que \n crée de nouvelles lignes et \t crée des tabulations.

2.2) Utiliser des commentaires pour expliquer le code

À mesure que vos programmes deviennent plus complexes, il devient important d’expliquer ce que fait votre code — à la fois pour les autres qui pourraient le lire et pour vous-même plus tard. Python fournit des commentaires à cet effet : des notes dans votre code que Python ignore complètement lors de l’exécution du programme.

2.2.1) Commentaires sur une seule ligne

En Python, tout texte qui suit un symbole # sur une ligne est un commentaire. Python ignore tout ce qui va du # jusqu’à la fin de cette ligne :

# comment_example.py
# This is a comment. Python ignores this line completely.
print("This line runs")  # This comment explains the print statement
# print("This line does NOT run because it's commented out")
print("This line also runs")

Output:

This line runs
This line also runs

Remarquez que la deuxième instruction print() ne s’est pas exécutée parce que toute la ligne était commentée. C’est utile lorsque vous voulez désactiver temporairement du code sans le supprimer.

Les commentaires peuvent apparaître seuls sur une ligne ou à la fin d’une ligne de code. Les deux styles sont courants :

# display_info.py
# Display a welcome message to the user
print("Welcome to the program!")
 
print("Processing data...")  # Inform the user of progress

2.2.2) Quand et comment écrire de bons commentaires

Les commentaires devraient expliquer pourquoi vous faites quelque chose, pas seulement ce que fait le code. Voici un exemple de mauvais commentaire :

# Bad comment - just repeats what the code obviously does
print("Hello")  # Print "Hello"

Ce commentaire n’apporte aucune valeur parce que toute personne lisant le code peut déjà voir qu’il affiche "Hello".

Voici une meilleure approche :

# Good comment - explains the purpose or context
# Greet the user before requesting their information
print("Hello")

Ce commentaire explique pourquoi nous affichons "Hello" — cela fait partie d’une interaction plus large avec l’utilisateur.

Lignes directrices pour écrire des commentaires utiles :

1. Expliquez le but : pourquoi ce code existe-t-il ? Quel problème résout-il ?
2. Clarifiez la logique complexe : si quelque chose n’est pas immédiatement évident, expliquez-le
3. Notez les décisions importantes : expliquez pourquoi vous avez choisi une approche plutôt qu’une autre
4. Signalez les pièges : mettez en évidence tout ce qui pourrait être déroutant ou inattendu
5. Gardez-les à jour : mettez à jour les commentaires lorsque vous modifiez le code

Voici un exemple montrant des commentaires efficaces :

# temperature_converter.py
# This program converts temperatures from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
# Display program title
print("Temperature Converter")
print("Fahrenheit to Celsius")
print()
 
# We'll learn how to get user input in section 2.4
# For now, we'll use a fixed temperature value
fahrenheit = 75  # Temperature in Fahrenheit to convert
 
# Perform the conversion using the standard formula
# Subtract 32 first (order matters due to the formula)
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print("Temperature:", fahrenheit, "°F =", celsius, "°C")

Output:

Temperature Converter
Fahrenheit to Celsius
 
Temperature: 75 °F = 23.88888888888889 °C

Remarquez comment les commentaires expliquent le but du programme, la formule utilisée et la logique du calcul. Ils rendent le code beaucoup plus facile à comprendre, en particulier pour quelqu’un qui le découvre pour la première fois.

2.2.3) Commentaires multilignes et docstrings

Pour des explications plus longues, vous pouvez utiliser plusieurs commentaires sur une seule ligne :

# multi_line_comments.py
# This program demonstrates a longer explanation
# that spans multiple lines. Each line starts
# with a # symbol.
print("Program starts here")

Python n’a pas de syntaxe spéciale de commentaire multiligne comme certains autres langages. Cependant, il existe une approche alternative utilisant des strings entre triples guillemets. Nous en apprendrons davantage au chapitre 19 lorsque nous parlerons des docstrings (chaînes de documentation pour les fonctions), mais en voici un aperçu :

# docstring_preview.py
"""
This is a multi-line string that can serve as a comment.
It's not technically a comment—it's a string that Python
creates but doesn't use. However, it's often used for
longer explanations at the beginning of files.
"""
print("Program starts here")

Pour l’instant, restez avec # pour les commentaires. Nous explorerons les strings entre triples guillemets et leurs usages appropriés dans les chapitres suivants.

2.2.4) Commenter du code pour les tests

Les commentaires sont aussi utiles pour désactiver temporairement du code pendant que vous testez :

# testing.py
print("This always runs")
# print("This is disabled for testing")
print("This also always runs")

Cette technique s’appelle "commenter" du code. Elle est utile lorsque vous voulez tester le comportement de votre programme sans certaines lignes, mais que vous ne voulez pas supprimer ces lignes définitivement.

2.3) Introduction aux variables et à l’affectation (aperçu)

Les programmes deviennent beaucoup plus utiles lorsqu’ils peuvent stocker et manipuler des données. Les variables sont des conteneurs nommés qui contiennent des valeurs. Pensez à une variable comme à une boîte étiquetée dans laquelle vous pouvez stocker des informations et les récupérer plus tard.

Remarque importante : cette section donne un aperçu des variables pour vous aider à comprendre les exemples de ce chapitre. Nous explorerons les variables en détail au chapitre 3, y compris les règles de nommage, les types de données et la façon dont Python gère les variables en interne. Pour l’instant, nous nous concentrerons sur le concept de base et son utilisation.

2.3.1) Créer des variables avec l’affectation

Vous créez une variable à l’aide de l’opérateur d’affectation (=). Le modèle de base est :

variable_name = value

Le nom de la variable se trouve à gauche, la valeur à droite, et le = les relie :

# variables_basic.py
message = "Hello, Python!"
print(message)

Output:

Hello, Python!

Voici ce qui se passe :

1. Python crée une variable nommée message
2. Python stocke la string "Hello, Python!" dans cette variable
3. Lorsque nous utilisons message dans la fonction print(), Python récupère la valeur stockée et l’affiche

Les variables peuvent stocker différents types de données. Voici quelques exemples :

# variable_types.py
greeting = "Welcome!"  # A string (text)
age = 25  # A number (integer)
price = 19.99  # A number with a decimal point (float)
is_student = True  # A boolean (True or False)
 
print(greeting)
print(age)
print(price)
print(is_student)

Output:

Welcome!
25
19.99
True

Nous étudierons ces différents types de données (strings, integers, floats, booleans) au chapitre 3. Pour l’instant, comprenez simplement que les variables peuvent contenir divers types d’informations.

2.3.2) Pourquoi les variables sont utiles

Les variables rendent votre code plus flexible et plus facile à maintenir. Comparez ces deux approches :

Sans variables :

# no_variables.py
print("Welcome, John!")
print("John, your account balance is $1000")
print("Thank you for banking with us, John!")

Avec variables :

# with_variables.py
name = "John"
balance = 1000
 
print("Welcome,", name + "!")
print(name, "your account balance is $", balance)
print("Thank you for banking with us,", name + "!")

Les deux programmes produisent une sortie similaire, mais la version avec variables présente des avantages importants :

1. Mises à jour faciles : pour changer le nom, vous n’avez à modifier qu’une seule ligne (name = "John") au lieu de trois
2. Moins d’erreurs : vous ne pouvez pas mal orthographier le nom à un endroit
3. Plus de flexibilité : vous pouvez plus tard changer la façon dont name obtient sa valeur (par exemple, en la demandant à l’utilisateur)

2.3.3) Réaffecter des variables

Les variables peuvent changer de valeur au cours de l’exécution du programme. C’est ce qu’on appelle la réaffectation :

# reassignment.py
score = 0
print("Initial score:", score)
 
score = 10
print("After first update:", score)
 
score = 25
print("After second update:", score)

Output:

Initial score: 0
After first update: 10
After second update: 25

Chaque fois que vous affectez une nouvelle valeur à une variable, Python remplace l’ancienne valeur par la nouvelle. L’ancienne valeur est abandonnée.

Vous pouvez même utiliser la valeur actuelle d’une variable pour calculer sa nouvelle valeur :

# updating_values.py
count = 5
print("Starting count:", count)
 
count = count + 1  # Add 1 to count
print("After adding 1:", count)
 
count = count + 10  # Add 10 to count
print("After adding 10:", count)

Output:

Starting count: 5
After adding 1: 6
After adding 10: 16

Ce modèle — count = count + 1 — est extrêmement courant en programmation. Il signifie "prenez la valeur actuelle de count, ajoutez-lui 1, et stockez le résultat à nouveau dans count". Nous apprendrons une forme abrégée pour cela (count += 1) au chapitre 4.

2.3.4) Aperçu du nommage des variables

Les noms de variables en Python doivent respecter certaines règles :

• Ils peuvent contenir des lettres, des chiffres et des underscores (_)
• Ils doivent commencer par une lettre ou un underscore (pas par un chiffre)
• Ils ne peuvent pas contenir d’espaces ni de caractères spéciaux comme @, $, %, etc.
• Ils ne peuvent pas être des mots-clés Python (mots réservés comme print, if, for, etc.)

Voici quelques noms de variables valides :

# valid_names.py
user_name = "Alice"
age2 = 30
_private_value = 42
totalPrice = 99.99

Et quelques noms invalides :

# These cause errors:
# 2age = 30  # Cannot start with a number
# user-name = "Alice"  # Cannot contain hyphens
# total price = 99.99  # Cannot contain spaces
# print = "Hello"  # Cannot use Python keywords

Bonne pratique : utilisez des noms descriptifs qui expliquent ce que représente la variable. user_age est meilleur que a, et total_price est meilleur que tp. Nous discuterons des conventions de nommage en détail au chapitre 3.

2.3.5) Les variables rendent les programmes dynamiques

La véritable puissance des variables apparaît lorsque vous les utilisez pour rendre les programmes plus dynamiques :

# dynamic_greeting.py
name = "Alice"
age = 28
city = "Seattle"
 
print("Personal Information")
print("====================")
print("Name:", name)
print("Age:", age)
print("City:", city)
print()
print("Summary:", name, "is", age, "years old and lives in", city)

Output:

Personal Information
====================
Name: Alice
Age: 28
City: Seattle
 
Summary: Alice is 28 years old and lives in Seattle

En modifiant les valeurs de name, age et city au début du programme, vous pouvez personnaliser toute la sortie sans changer les instructions print(). Cette séparation entre les données et la logique est un principe fondamental de la bonne programmation.

Regard vers l’avenir : au chapitre 3, nous explorerons les variables de façon approfondie, y compris les types de données, les conversions de type, les règles de nommage, et la manière dont Python gère les variables en interne. Pour l’instant, vous avez suffisamment de notions pour utiliser des variables dans des programmes simples.

2.4) Lire les entrées clavier avec input()

Jusqu’à présent, toutes les données de nos programmes étaient codées en dur — écrites directement dans le code. Mais les vrais programmes ont souvent besoin d’interagir avec les utilisateurs, en acceptant les informations qu’ils fournissent. La fonction input() de Python rend cela possible.

2.4.1) Entrée de base

La fonction input() affiche un message (appelé prompt) et attend que l’utilisateur tape quelque chose puis appuie sur Entrée. Voici le modèle de base :

# basic_input.py
name = input("What is your name? ")
print("Hello,", name + "!")

Lorsque vous exécutez ce programme, voici ce qui se passe :

What is your name? Alice
Hello, Alice!

Analysons cela :

1. Python exécute input("What is your name? ")
2. Python affiche le prompt : What is your name?
3. Le programme se met en pause et attend que l’utilisateur tape quelque chose
4. L’utilisateur tape Alice et appuie sur Entrée
5. Python stocke le texte "Alice" dans la variable name
6. Le programme continue et affiche le message de bienvenue

Le texte que vous fournissez à input() est le prompt — ce que l’utilisateur voit avant de taper. Ajoutez toujours un espace à la fin de votre prompt (remarquez l’espace après le point d’interrogation) pour séparer le prompt de la saisie de l’utilisateur, ce qui rend le tout plus lisible.

2.4.2) input() renvoie toujours une string

C’est un point crucial : input() renvoie toujours une string, même si l’utilisateur tape des nombres :

# input_as_string.py
age = input("How old are you? ")
print("You entered:", age)
print("The type is:", type(age))

Lorsque vous exécutez ce programme et entrez 25 :

How old are you? 25
You entered: 25
The type is: <class 'str'>

Même si l’utilisateur a tapé 25, Python le stocke sous forme de string "25", et non comme le nombre 25. La fonction type() le confirme — elle montre que age est une string (str), pas un integer.

Cela a de l’importance lorsque vous voulez effectuer des calculs. Vous ne pouvez pas faire directement des opérations mathématiques avec des strings :

# This causes an error:
age = input("How old are you? ")
next_year_age = age + 1  # Error! Can't add a number to a string

Cela produit une erreur parce que Python ne sait pas comment ajouter le nombre 1 à la string "25".

2.4.3) Convertir les entrées en nombres

Pour utiliser une entrée comme nombre, vous devez la convertir explicitement à l’aide de int() (pour les nombres entiers) ou float() (pour les nombres décimaux) :

# input_conversion.py
age_string = input("How old are you? ")
age = int(age_string)  # Convert string to integer
 
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Lorsque vous exécutez ce programme et entrez 25 :

How old are you? 25
Next year, you will be 26 years old

Vous pouvez également combiner la saisie et la conversion sur une seule ligne :

# input_conversion_compact.py
age = int(input("How old are you? "))
next_year = age + 1
print("Next year, you will be", next_year, "years old")

C’est plus concis et c’est le style que vous verrez le plus souvent. Cela fonctionne de l’intérieur vers l’extérieur :

1. input("How old are you? ") obtient la saisie de l’utilisateur sous forme de string
2. int(...) convertit cette string en integer
3. L’integer est stocké dans la variable age

Voici un exemple utilisant float() pour les nombres décimaux :

# float_input.py
price = float(input("Enter the price: $"))
tax_rate = 0.08
tax = price * tax_rate
total = price + tax
 
print("Price: $", price)
print("Tax: $", tax)
print("Total: $", total)

Lorsque vous exécutez ce programme et entrez 19.99 :

Enter the price: $19.99
Price: $ 19.99
Tax: $ 1.5992
Total: $ 21.5892

Important : si l’utilisateur entre un texte qui ne peut pas être converti en nombre, Python lèvera une erreur. Par exemple, si vous utilisez int(input("Enter a number: ")) et que l’utilisateur tape "hello", Python ne peut pas convertir "hello" en integer et affichera un message d’erreur. Nous apprendrons à gérer ces situations proprement au chapitre 27 lorsque nous étudierons la gestion des exceptions.

2.4.4) Entrées multiples

Les programmes ont souvent besoin de plusieurs informations de la part de l’utilisateur. Il suffit d’appeler input() plusieurs fois :

# multiple_inputs.py
print("Please enter your information:")
print()
 
first_name = input("First name: ")
last_name = input("Last name: ")
age = int(input("Age: "))
city = input("City: ")
 
print()
print("Summary")
print("=======")
print("Name:", first_name, last_name)
print("Age:", age)
print("Location:", city)

Example interaction:

Please enter your information:
 
First name: John
Last name: Smith
Age: 30
City: Boston
 
Summary
=======
Name: John Smith
Age: 30
Location: Boston

Remarquez comment le programme demande séparément chaque information. Cela rend clair pour l’utilisateur ce qu’il doit fournir et dans quel ordre.

2.4.5) Créer des prompts informatifs

De bons prompts rendent vos programmes plus faciles à utiliser. Voici quelques lignes directrices :

Soyez précis sur ce que vous voulez :

# Good prompts
name = input("Enter your full name: ")
temperature = float(input("Enter temperature in Fahrenheit: "))
quantity = int(input("How many items do you want to purchase? "))

Indiquez le format ou les unités attendus :

# format_prompts.py
date = input("Enter date (MM/DD/YYYY): ")
phone = input("Enter phone number (XXX-XXX-XXXX): ")
price = float(input("Enter price in dollars (without $): "))

Utilisez un langage clair et convivial :

# friendly_prompts.py
print("Welcome to the Temperature Converter!")
print()
temp = float(input("Please enter a temperature in Fahrenheit: "))

Des prompts clairs réduisent la confusion de l’utilisateur et rendent vos programmes plus professionnels.

2.5) Programmes simples input-process-output

La plupart des programmes suivent un modèle courant appelé Input-Process-Output (IPO) :

1. Input : obtenir des données de l’utilisateur ou d’une autre source
2. Process : effectuer des calculs ou des transformations sur les données
3. Output : afficher les résultats

Ce modèle est tellement fondamental que vous l’utiliserez dans d’innombrables programmes tout au long de votre parcours de programmation. Explorons-le à travers plusieurs exemples complets.

2.5.1) Exemple : convertisseur de température

Créons un programme complet qui convertit des températures de Fahrenheit en Celsius :

# temperature_converter.py
# This program converts a temperature from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
print("Temperature Converter")
print("Fahrenheit to Celsius")
print("=" * 30)  # Print a line of equal signs
print()
 
# INPUT: Get temperature from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# PROCESS: Convert using the formula
celsius = (fahrenheit - 32) * 5 / 9
 
# OUTPUT: Display the result
print()
print("Result:", fahrenheit, "°F =", celsius, "°C")

Example interaction:

Temperature Converter
Fahrenheit to Celsius
==============================
 
Enter temperature in Fahrenheit: 75
 
Result: 75.0 °F = 23.88888888888889 °C

Remarquez comment le programme suit clairement le modèle IPO :

• Input : obtenir la température en Fahrenheit
• Process : appliquer la formule de conversion
• Output : afficher le résultat en Celsius

Les commentaires dans le code marquent explicitement ces trois sections, ce qui rend la structure du programme claire.

2.5.2) Exemple : calculateur d’aire de rectangle

Voici un autre exemple IPO qui calcule l’aire d’un rectangle :

# rectangle_area.py
# Calculate the area of a rectangle
# Formula: Area = length × width
 
print("Rectangle Area Calculator")
print("=" * 30)
print()
 
# INPUT: Get dimensions from user
length = float(input("Enter the length: "))
width = float(input("Enter the width: "))
 
# PROCESS: Calculate area
area = length * width
 
# OUTPUT: Display the result
print()
print("A rectangle with length", length, "and width", width)
print("has an area of", area, "square units")

Example interaction:

Rectangle Area Calculator
==============================
 
Enter the length: 5.5
Enter the width: 3.2
 
A rectangle with length 5.5 and width 3.2
has an area of 17.6 square units

2.5.3) Exemple : calculateur de total d’achats

Cet exemple calcule un total d’achats avec taxe :

# shopping_total.py
# Calculate total cost including tax
 
print("Shopping Total Calculator")
print("=" * 30)
print()
 
# INPUT: Get price and tax rate
price = float(input("Enter item price: $"))
tax_rate = float(input("Enter tax rate (as decimal, e.g., 0.08 for 8%): "))
 
# PROCESS: Calculate tax and total
tax_amount = price * tax_rate
total = price + tax_amount
 
# OUTPUT: Display itemized breakdown
# Note: Comma in print() adds a space after $
print()
print("Purchase Summary")
print("-" * 30)
print("Item price:    $", price)
print("Tax rate:      ", tax_rate * 100, "%")
print("Tax amount:    $", tax_amount)
print("-" * 30)
print("Total:         $", total)

Example interaction:

Shopping Total Calculator
==============================
 
Enter item price: $49.99
Enter tax rate (as decimal, e.g., 0.08 for 8%): 0.08
 
Purchase Summary
------------------------------
Item price:    $ 49.99
Tax rate:       8.0 %
Tax amount:    $ 3.9992
------------------------------
Total:         $ 53.9892

2.6) Débogage de base en lisant les messages d’erreur simples

Même les programmeurs expérimentés commettent des erreurs. Apprendre à lire et à comprendre les messages d’erreur est une compétence essentielle qui vous fera gagner d’innombrables heures de frustration. Les messages d’erreur de Python sont en fait assez utiles — ils vous disent ce qui s’est mal passé et où le problème s’est produit.

Les termes "message d’erreur" et "traceback" sont liés mais légèrement différents : un traceback est le rapport complet que Python affiche lorsqu’une erreur se produit, comprenant le type d’erreur, sa description, et le chemin parcouru dans votre code qui a mené à l’erreur. Le message d’erreur est la dernière ligne du traceback qui décrit ce qui s’est mal passé. Dans les conversations courantes, les programmeurs utilisent souvent "message d’erreur" pour désigner tout le traceback.

2.6.1) Comprendre les messages d’erreur

Lorsque Python rencontre une erreur, il affiche un traceback — un rapport détaillé sur ce qui s’est mal passé. Regardons un exemple simple :

# error_example.py
print("Starting the program")
print("This line works fine"
print("This line might not be reached")

Lorsque vous essayez d’exécuter ce script, Python affiche :

  File "error_example.py", line 2
    print("This line works fine"
                                ^
SyntaxError: '(' was never closed

Décomposons ce que ce message d’erreur nous dit :

1. Nom de fichier : error_example.py - le fichier dans lequel l’erreur s’est produite
2. Numéro de ligne : line 2 - l’endroit où Python a détecté le problème
3. Extrait de code : affiche la ligne problématique avec un ^ pointant là où Python a remarqué le problème
4. Type d’erreur : SyntaxError - le genre d’erreur survenu
5. Description : '(' was never closed - une explication lisible par un humain

L’erreur s’est produite parce que nous avons oublié la parenthèse fermante sur la ligne 2. Python a essayé de continuer à lire la ligne suivante comme faisant partie de la même instruction print() et s’est trouvé perdu.

2.6.2) Types d’erreurs courants pour les débutants

Explorons les erreurs les plus courantes que vous rencontrerez en tant que débutant et comment les corriger.

SyntaxError: Invalid Syntax

C’est l’erreur la plus fréquente pour les débutants. Elle signifie que Python n’a pas pu comprendre votre code parce qu’il ne suit pas les règles de grammaire de Python.

Deux-points manquant :

# missing_colon.py
name = input("What is your name? ")
if name == "Alice"  # Missing colon
    print("Hello, Alice!")

Error:

  File "missing_colon.py", line 2
    if name == "Alice"
                     ^
SyntaxError: expected ':'

Remarque : nous n’avons pas encore appris les instructions if — nous les verrons au chapitre 8. Cet exemple montre seulement à quoi ressemble l’erreur.

Guillemets mal appariés :

# mismatched_quotes.py
message = "Hello, world!'
print(message)

Error:

  File "mismatched_quotes.py", line 1
    message = "Hello, world!'
              ^
SyntaxError: unterminated string literal (detected at line 1)

L’erreur se produit parce que la string commence par un guillemet double (") mais se termine par un guillemet simple ('). Python s’attend au même type de guillemet au début et à la fin.

NameError: Name Not Defined

Cette erreur se produit lorsque vous essayez d’utiliser une variable qui n’existe pas :

# name_error.py
print("Starting calculation")
result = total + 10  # 'total' was never created
print(result)

Error:

Traceback (most recent call last):
  File "name_error.py", line 2, in <module>
    result = total + 10
             ^^^^^
NameError: name 'total' is not defined

Python vous indique qu’il ne sait pas ce qu’est total parce que vous n’avez jamais créé cette variable. La correction consiste à définir total avant de l’utiliser :

# name_error_fixed.py
print("Starting calculation")
total = 0  # Define the variable first
result = total + 10
print(result)

Causes courantes de NameError :

• Fautes de frappe dans les noms de variables (totla au lieu de total)
• Utilisation d’une variable avant de lui avoir affecté une valeur
• Oubli pur et simple de créer une variable

TypeError: Unsupported Operand Type(s)

Cette erreur se produit lorsque vous essayez d’effectuer une opération sur des types incompatibles :

# type_error.py
age = input("How old are you? ")
next_year = age + 1  # Can't add a number to a string
print("Next year:", next_year)

Error:

Traceback (most recent call last):
  File "type_error.py", line 2, in <module>
    next_year = age + 1
                ~~~~^~~
TypeError: can only concatenate str (not "int") to str

Python vous dit que age est une string (parce que input() renvoie des strings), et que vous ne pouvez pas ajouter un nombre à une string. La correction consiste à convertir l’entrée en integer :

# type_error_fixed.py
age = int(input("How old are you? "))  # Convert to integer
next_year = age + 1
print("Next year:", next_year)

ValueError: Invalid Literal

Cette erreur se produit lorsque vous essayez de convertir une string en nombre, mais que la string ne représente pas un nombre valide :

# value_error.py
age = int(input("How old are you? "))
print("You are", age, "years old")

Si l’utilisateur entre du texte au lieu d’un nombre :

How old are you? twenty
Traceback (most recent call last):
  File "value_error.py", line 1, in <module>
    age = int(input("How old are you? "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'twenty'

Python vous indique qu’il ne peut pas convertir la string "twenty" en integer. L’utilisateur doit entrer un nombre comme 20 à la place.

Important : pour l’instant, si les utilisateurs entrent une saisie invalide, votre programme plantera avec une erreur. C’est normal pour des programmes de débutant. Au chapitre 27, nous apprendrons à gérer ces situations proprement avec la gestion des exceptions, ce qui permettra à votre programme de se remettre d’erreurs et de demander à l’utilisateur de réessayer.

2.6.3) Lire les tracebacks attentivement

Lorsqu’une erreur se produit, Python affiche un traceback qui remonte à la source de l’erreur dans votre code. Pour des programmes simples, le traceback est court :

# simple_traceback.py
print("Starting program")
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello,", name)
print("Next year you'll be", age + 1)

Si l’utilisateur entre une saisie invalide pour age :

Starting program
Enter your name: Alice
Enter your age: abc
Traceback (most recent call last):
  File "simple_traceback.py", line 3, in <module>
    age = int(input("Enter your age: "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

Le traceback montre :

1. Le nom du fichier et le numéro de ligne où l’erreur s’est produite
2. La ligne de code exacte qui a causé le problème
3. Le type d’erreur et une description

Stratégie de lecture : commencez par le bas du traceback et remontez. La dernière ligne vous dit ce qui s’est mal passé. Les lignes au-dessus montrent où, dans votre code, l’erreur s’est produite.

2.6.4) Stratégies de débogage courantes

Lorsque vous rencontrez une erreur, suivez ces étapes :

1. Lisez attentivement le message d’erreur

Ne paniquez pas ! Le message d’erreur essaie de vous aider. Lisez-le complètement et essayez de comprendre ce qu’il dit.

2. Regardez le numéro de ligne

Le message d’erreur vous indique quelle ligne Python considère comme problématique. Cependant, il arrive que l’erreur réelle se trouve sur la ligne précédente. Par exemple, une parenthèse fermante manquante sur la ligne 2 peut ne pas être détectée avant que Python ne lise la ligne 3.

3. Vérifiez les erreurs courantes

• Guillemets manquants ou mal appariés
• Parenthèses ou crochets fermants manquants
• Deux-points manquants (pour des instructions que nous verrons plus tard comme if, for, while)
• Fautes de frappe dans les noms de variables
• Oubli de convertir une entrée en nombre

4. Utilisez print() pour inspecter les valeurs

Si vous n’êtes pas sûr de ce qui ne va pas, ajoutez des instructions print() pour voir quelles valeurs contiennent vos variables :

# debugging_with_print.py
price = input("Enter price: ")
print("DEBUG: price =", price, "type =", type(price))  # Debugging line
 
tax = price * 0.08  # This will cause an error
print("Tax:", tax)

La ligne de debug vous montre que price est une string, pas un nombre, ce qui vous aide à identifier le problème.

5. Commentez du code pour isoler le problème

Si vous avez plusieurs lignes et que vous ne savez pas laquelle cause l’erreur, commentez des lignes jusqu’à ce que l’erreur disparaisse :

# isolating_error.py
name = input("Enter name: ")
# age = int(input("Enter age: "))  # Commented out for testing
# city = input("Enter city: ")  # Commented out for testing
print("Name:", name)

Une fois que l’erreur disparaît, vous savez que le problème se trouve dans l’une des lignes commentées.

6. Commencez par une version simple

Si votre programme ne fonctionne pas, simplifiez-le au strict minimum :

# simplified_version.py
# Start with just the basic structure
print("Program starting")
# Add one feature at a time and test

Une fois que la version simple fonctionne, ajoutez des fonctionnalités une par une, en testant après chaque ajout.

2.6.5) Prévenir les erreurs

Si le débogage est important, prévenir les erreurs dès le départ est encore mieux :

Écrivez du code de manière incrémentale

Ne rédigez pas tout votre programme d’un coup pour ne l’exécuter qu’ensuite. Écrivez quelques lignes, exécutez le programme, vérifiez que ces lignes fonctionnent, puis ajoutez-en d’autres. Ainsi, lorsque l’erreur apparaît, vous savez qu’elle se trouve dans le code que vous venez d’ajouter.

# incremental_development.py
# Step 1: Get input and test
name = input("Enter name: ")
print("DEBUG: Got name:", name)
 
# Step 2: Add more input and test
# age = int(input("Enter age: "))
# print("DEBUG: Got age:", age)
 
# Step 3: Add processing and test
# ... and so on

Utilisez des noms de variables descriptifs

Des noms de variables clairs vous aident à éviter les erreurs :

# Clear variable names make errors less likely
user_age = int(input("Enter your age: "))
next_year_age = user_age + 1

Ajoutez des commentaires pour expliquer votre logique

Les commentaires vous aident (vous et les autres) à comprendre ce que le code est censé faire, ce qui facilite la détection des cas où il fait autre chose :

# temperature_with_comments.py
# Get temperature in Fahrenheit from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# Convert to Celsius using the standard formula: C = (F - 32) × 5/9
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print(fahrenheit, "°F =", celsius, "°C")

Testez avec différentes entrées

Ne testez pas votre programme une seule fois. Essayez différentes entrées, y compris des cas limites :

• Valeurs normales : 25, 100
• Zéro : 0
• Nombres négatifs : -10
• Nombres décimaux : 3.14
• Très grands nombres : 1000000

Cela vous aide à découvrir des problèmes avant que les utilisateurs ne les rencontrent.

2.6.6) Quand demander de l’aide

Parfois, vous rencontrerez des erreurs que vous ne parviendrez pas à résoudre seul. Avant de demander de l’aide :

1. Lisez attentivement le message d’erreur — assurez-vous de comprendre ce qu’il dit
2. Recherchez l’erreur — copiez le message d’erreur (sans vos noms de variables spécifiques) et cherchez-le en ligne. Beaucoup d’erreurs ont déjà été rencontrées et résolues par d’autres
3. Vérifiez soigneusement votre code — regardez s’il y a des fautes de frappe, de la ponctuation manquante et des erreurs courantes
4. Créez un exemple minimal — réduisez votre code à la plus petite version qui produit encore l’erreur

Lorsque vous demandez de l’aide, fournissez :

• Le message d’erreur complet
• Le code qui produit l’erreur
• Ce que vous attendiez
• Ce qui s’est réellement passé
• Ce que vous avez déjà essayé

Souvenez-vous : les erreurs font partie intégrante de la programmation. Tous les programmeurs, des débutants aux experts, rencontrent des erreurs quotidiennement. La différence est que les programmeurs expérimentés ont appris à lire les messages d’erreur efficacement et connaissent les solutions courantes. Vous développerez ces compétences avec la pratique.

Vous avez maintenant appris les éléments fondamentaux de la programmation en Python : afficher des sorties avec print(), documenter le code avec des commentaires, stocker des données dans des variables, obtenir des entrées utilisateur avec input(), suivre le modèle input-process-output, et déboguer des erreurs simples.

Ces concepts constituent la base de tout le reste que vous apprendrez en Python. Au chapitre suivant, nous approfondirons les variables et explorerons les types de données de base de Python, ce qui vous donnera une compréhension plus complète de la façon dont Python stocke et manipule différents types d’informations.

Points clés à retenir de ce chapitre :

• Utilisez print() pour afficher du texte et d’autres informations aux utilisateurs
• Utilisez les commentaires (#) pour expliquer votre code et documenter votre réflexion
• Stockez des données dans des variables à l’aide de l’affectation (=)
• Obtenez des entrées utilisateur avec input() et convertissez-les en nombres si nécessaire
• Structurez vos programmes en suivant le modèle input-process-output
• Lisez attentivement les messages d’erreur — ils essaient de vous aider à corriger les problèmes
• Écrivez du code de manière incrémentale et testez fréquemment pour détecter les erreurs tôt

Avec ces compétences, vous pouvez maintenant écrire des programmes interactifs simples mais complets. En continuant à apprendre, vous vous appuierez sur ces bases pour créer des applications de plus en plus sophistiquées.