1. Premiers pas avec Python

Bienvenue dans votre parcours d'apprentissage de la programmation Python ! Ce chapitre va vous guider à travers les premiers pas essentiels : comprendre ce qu'est Python, l'installer sur votre ordinateur et exécuter votre premier code Python. À la fin de ce chapitre, vous serez à l'aise avec l'utilisation du shell interactif de Python, la création et l'exécution de fichiers de script, ainsi que la compréhension des messages d'erreur de base que Python vous renvoie.

1.1) Qu'est-ce qu'un programme et que fait Python ?

Avant de plonger dans Python spécifiquement, voyons ce qu'est un programme et quel rôle Python joue dans la création de programmes.

1.1.1) Comprendre les programmes

Un programme est un ensemble d'instructions qui indiquent à un ordinateur ce qu'il doit faire. De la même façon qu'une recette vous indique étape par étape comment faire un gâteau, un programme indique à un ordinateur étape par étape comment accomplir une tâche. Ces tâches peuvent aller de simples calculs à des opérations complexes comme l'affichage de pages web, le traitement d'images ou le contrôle de robots.

Les ordinateurs ne comprennent pas directement les langues humaines comme l'anglais ou l'espagnol. Ils comprennent uniquement le code machine — des séquences de nombres binaires (0 et 1) qui représentent des opérations très basiques. Écrire des programmes directement en code machine serait extrêmement difficile et sujet à erreurs pour les humains.

C'est là qu'interviennent les langages de programmation. Un langage de programmation est une manière lisible par l'humain d'écrire des instructions qui peuvent être traduites en code machine. Python est l'un de ces langages de programmation, conçu pour être particulièrement facile à lire et à écrire pour les humains.

1.1.2) Ce qui rend Python particulier

Python est un langage de programmation de haut niveau, ce qui signifie qu'il masque beaucoup de détails complexes que vous devriez gérer dans des langages de plus bas niveau. Voici ce qui rend Python particulièrement attractif à la fois pour les débutants et pour les professionnels :

Syntaxe lisible : le code Python se lit presque comme de l'anglais. Par exemple, pour afficher "Hello, World!" en Python, vous écrivez :

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

Sortie :

Hello, World!

Comparez cela à des langages comme C ou Java, qui nécessitent plus de code « standard » (boilerplate) pour accomplir la même tâche.

Langage interprété : Python est un langage interprété. Cela signifie que vous n'avez pas besoin de compiler votre code en code machine avant de l'exécuter. À la place, un programme appelé l'interpréteur Python lit votre code et l'exécute ligne par ligne. Cela rend le développement plus rapide, car vous pouvez voir immédiatement le résultat de vos modifications de code.

Polyvalent et puissant : malgré son côté adapté aux débutants, Python est utilisé dans des environnements professionnels pour :

• Le développement web (sites web et applications web)
• L'analyse de données et la visualisation
• Le machine learning et l'intelligence artificielle
• Le calcul scientifique
• L'automatisation et le scripting
• Le développement de jeux
• Et bien plus encore

Grande communauté et bibliothèques : Python a une communauté d'utilisateurs immense et des milliers de bibliothèques de code pré-écrites qui étendent ses capacités. Cela signifie que les solutions aux problèmes courants sont souvent à portée d'un simple import de bibliothèque.

1.1.3) Comment Python exécute votre code

Lorsque vous écrivez du code Python et que vous l'exécutez, voici ce qui se passe en coulisses :

1. Vous écrivez du code : vous créez un fichier contenant des instructions Python ou vous les tapez directement dans le shell interactif de Python.

2. L'interpréteur lit votre code : l'interpréteur Python vérifie votre code à la recherche d'erreurs de syntaxe (des erreurs dans la manière dont vous avez écrit le code).

3. Traduction en bytecode : s'il n'y a pas d'erreurs de syntaxe, Python traduit votre code en une forme intermédiaire appelée bytecode. Le bytecode est une forme intermédiaire de votre code — une traduction dans un langage à mi-chemin entre Python et le code machine. Il est plus simple à exécuter pour l'ordinateur que le Python lui-même, mais plus abstrait que le code machine pur.

4. Exécution : la machine virtuelle Python (PVM) exécute le bytecode, en effectuant les opérations que vous avez spécifiées.

5. Sortie : vous voyez le résultat de votre programme — que ce soit du texte affiché à l'écran, un fichier créé ou toute autre action.

La beauté de ce processus est que vous n'avez pas à vous soucier de la plupart de ces étapes. Vous écrivez du code, vous l'exécutez et vous voyez les résultats. L'interpréteur s'occupe du reste.

1.2) Installer Python et exécuter l'interpréteur

Pour commencer à programmer en Python, vous devez d'abord installer Python sur votre ordinateur. Cette section va vous guider à travers le processus d'installation et vérifier que tout fonctionne correctement.

1.2.1) Vérifier si Python est déjà installé

Certains systèmes d'exploitation sont livrés avec Python pré-installé. Avant de télécharger quoi que ce soit, voyons si Python est déjà présent sur votre système.

Sous Windows :

1. Ouvrez l'invite de commandes (Command Prompt) :

   • Appuyez sur Windows + R pour ouvrir la boîte de dialogue Exécuter
   • Tapez cmd et appuyez sur Entrée

2. Tapez la commande suivante et appuyez sur Entrée :

python --version

Si Python est installé, vous verrez une sortie du type :

Python 3.11.5

Si vous voyez un message d'erreur du type 'python' is not recognized as an internal or external command, Python n'est pas installé ou n'est pas dans votre variable d'environnement PATH.

Sous macOS :

1. Ouvrez l'application Terminal :

   • Appuyez sur Commande + Espace pour ouvrir Spotlight
   • Tapez Terminal et appuyez sur Entrée

2. Tapez la commande suivante et appuyez sur Entrée :

python3 --version

Remarque : sous macOS, vous utilisez généralement python3 au lieu de python, car python peut faire référence à Python 2, qui est obsolète.

Si Python 3 est installé, vous verrez une sortie du type :

Python 3.11.5

Sous Linux :

1. Ouvrez votre application de terminal (cela varie selon la distribution)

2. Tapez la commande suivante et appuyez sur Entrée :

python3 --version

La plupart des distributions Linux modernes sont livrées avec Python 3 pré-installé.

1.2.2) Télécharger et installer Python

Si Python n'est pas installé ou si vous avez une version plus ancienne, suivez ces étapes pour installer la dernière version.

Installation sous Windows :

1. Visitez le site officiel de Python : https://www.python.org/downloads/

2. Cliquez sur le bouton "Download Python" (il affichera la dernière version, par exemple "Download Python 3.11.5")

3. Exécutez le programme d'installation téléchargé (fichier .exe)

4. Important : sur le premier écran de l'installateur, cochez la case qui dit "Add Python to PATH". C'est crucial — cela vous permet d'exécuter Python depuis n'importe quelle invite de commandes.

   Ce qui se passe si vous oubliez : si vous ne cochez pas "Add Python to PATH", vous ne pourrez pas exécuter Python depuis la ligne de commande, et vous verrez une erreur comme 'python' is not recognized as an internal or external command. Si cela arrive, vous devrez soit réinstaller Python (en cochant la case cette fois), soit ajouter Python manuellement à votre PATH, ce qui est plus complexe pour les débutants.

5. Cliquez sur "Install Now" et attendez la fin de l'installation

6. Vérifiez l'installation en ouvrant une nouvelle invite de commandes et en tapant :

python --version

Vous devriez voir le numéro de version que vous venez d'installer.

Installation sous macOS :

1. Visitez https://www.python.org/downloads/

2. Cliquez sur le bouton "Download Python" pour la dernière version

3. Ouvrez le fichier .pkg téléchargé et suivez l'assistant d'installation

4. Vérifiez l'installation en ouvrant Terminal et en tapant :

python3 --version

Installation sous Linux :

La plupart des distributions Linux sont livrées avec Python 3, mais si vous devez l'installer ou le mettre à jour :

Pour les systèmes basés sur Ubuntu/Debian :

sudo apt update
sudo apt install python3

Pour les systèmes basés sur Fedora/Red Hat :

sudo dnf install python3

Vérifiez avec :

python3 --version

1.2.3) Exécuter l'interpréteur Python

Une fois Python installé, vous pouvez exécuter l'interpréteur Python directement depuis votre ligne de commande ou votre terminal. L'interpréteur est le programme qui exécute le code Python. Lancer directement l'interpréteur ouvre le shell interactif (REPL), que nous explorerons en détail dans la section suivante. C'est différent de l'exécution d'un fichier de script, que nous verrons en section 1.4.

Sous Windows :

Ouvrez l'invite de commandes et tapez :

python

Sous macOS et Linux :

Ouvrez le Terminal et tapez :

python3

Vous devriez voir quelque chose comme ceci :

Python 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

L'invite >>> indique que Python est prêt à accepter vos commandes. Ceci est appelé le shell interactif Python ou REPL (Read-Eval-Print Loop), que nous allons explorer en détail dans la section suivante.

Pour quitter l'interpréteur, vous pouvez :

• Taper exit() puis appuyer sur Entrée
• Taper quit() puis appuyer sur Entrée
• Appuyer sur Ctrl + D (sur macOS/Linux) ou Ctrl + Z puis Entrée (sur Windows)

Félicitations ! Vous avez installé Python avec succès et vérifié que l'interpréteur fonctionne. Vous êtes maintenant prêt à commencer à écrire du code Python.

1.3) Utiliser le shell interactif Python (REPL)

Le shell interactif Python, couramment appelé REPL (Read-Eval-Print Loop), est l'une des fonctionnalités les plus utiles de Python pour l'apprentissage et l'expérimentation. Il vous permet de taper du code Python et de voir immédiatement les résultats, ce qui le rend parfait pour essayer de nouveaux concepts, tester de petits bouts de code et explorer les capacités de Python.

1.3.1) Qu'est-ce que le REPL ?

Le shell interactif Python, couramment appelé REPL (Read-Eval-Print Loop), est l'une des fonctionnalités les plus utiles de Python pour l'apprentissage et l'expérimentation. Le REPL est aussi appelé shell interactif Python ou simplement interpréteur interactif — tous ces termes désignent la même chose : l'invite >>> où vous pouvez taper du code Python et voir des résultats immédiats.

REPL signifie :

• Read : Python lit le code que vous tapez
• Eval : Python évalue (exécute) ce code
• Print : Python affiche le résultat
• Loop : Python revient au début pour lire plus de code

Ce cycle continue jusqu'à ce que vous quittiez le REPL. C'est un peu comme avoir une conversation avec Python — vous lui donnez une instruction, il répond, et vous pouvez immédiatement lui donner une autre instruction basée sur cette réponse.

1.3.2) Démarrer et utiliser le REPL

Pour démarrer le REPL, ouvrez votre ligne de commande ou votre terminal et tapez python (Windows) ou python3 (macOS/Linux), comme nous l'avons fait dans la section précédente.

Une fois que vous voyez l'invite >>>, vous pouvez commencer à taper du code Python. Essayons quelques exemples de base :

Arithmétique simple :

>>> 5 + 3
8
>>> 10 * 2
20
>>> 15 / 3
5.0

Remarquez que vous n'avez pas besoin d'utiliser print() dans le REPL — Python affiche automatiquement le résultat de chaque expression. C'est l'un des avantages du REPL.

Travailler avec du texte :

>>> "Hello, World!"
'Hello, World!'
>>> "Python" + " is " + "great"
'Python is great'

Quand vous tapez uniquement une chaîne (du texte entre guillemets), Python l'affiche avec des guillemets — c'est la manière dont Python représente la chaîne. Si vous voulez afficher du texte sans guillemets, utilisez la fonction print() :

>>> print("Hello, World!")
Hello, World!

Remarquez la différence : taper simplement la chaîne l'affiche avec des guillemets (la représentation de Python), tandis que print() l'affiche sans guillemets (le texte réel).

Stocker des valeurs dans des variables :

Bien que taper directement des valeurs soit utile pour des tests rapides, vous voudrez souvent stocker des valeurs dans des variables — des conteneurs nommés qui contiennent des données que vous pouvez réutiliser dans votre programme.

>>> name = "Alice"
>>> name
'Alice'
>>> age = 25
>>> age
25

Quand vous affectez une valeur à une variable (comme name = "Alice"), Python n'affiche rien. Mais lorsque vous tapez simplement le nom de la variable, Python affiche sa valeur.

Utiliser Python comme calculatrice :

>>> 2 + 2
4
>>> (10 + 5) * 2
30
>>> 100 / 4
25.0
>>> 7 % 3
1

Le REPL est excellent pour des calculs rapides et pour tester des expressions mathématiques.

1.3.3) Saisie multi-lignes dans le REPL

Parfois, vous avez besoin d'écrire du code qui s'étend sur plusieurs lignes, comme des définitions de fonction. Le REPL gère cela élégamment en changeant son invite. Lorsque vous commencez une instruction multi-lignes, l'invite passe de >>> à ... pour indiquer que Python attend que vous complétiez l'instruction.

Voici un exemple simple utilisant une fonction (Remarque : nous apprendrons les fonctions en détail au chapitre 19. Cet exemple montre simplement comment le REPL gère la saisie multi-lignes avec l'invite de continuation ...) :

>>> def greet():
...     print("Hello!")
...
>>> greet()
Hello!

Après avoir tapé la première ligne et appuyé sur Entrée, l'invite devient .... Vous tapez la ligne indentée, appuyez sur Entrée, puis appuyez à nouveau sur Entrée sur une ligne vide pour exécuter le code.

1.3.4) Accéder aux commandes précédentes

Le REPL conserve un historique des commandes que vous avez tapées. Vous pouvez utiliser les touches fléchées vers le haut et vers le bas pour naviguer dans cet historique :

• Flèche haut : affiche la commande précédente
• Flèche bas : affiche la commande suivante (si vous êtes remonté en arrière)

C'est extrêmement utile lorsque vous voulez modifier et réexécuter une commande, ou lorsque vous voulez vous rappeler ce que vous avez tapé plus tôt.

1.3.5) Obtenir de l'aide dans le REPL

Le REPL de Python possède des fonctionnalités d'aide intégrées. Vous pouvez obtenir des informations sur les objets, fonctions et modules Python directement.

Ces fonctionnalités d'aide sont particulièrement utiles lorsque vous explorez Python et que vous voulez découvrir ce qui est disponible. Par exemple, si vous travaillez avec des chaînes de caractères et que vous vous demandez quelles méthodes sont disponibles, dir(str) vous montre toutes les options. Au fur et à mesure que vous progresserez dans ce livre, vous trouverez ces outils de plus en plus précieux pour votre exploration autonome.

>>> help()

Cela vous fait entrer dans le système d'aide. Vous pouvez ensuite taper le nom de ce sur quoi vous voulez de l'aide, ou taper quit pour quitter le système d'aide.

Vous pouvez aussi obtenir directement de l'aide sur des éléments spécifiques :

>>> help(print)

Cela affiche la documentation de la fonction print(). Appuyez sur q pour quitter l'affichage de l'aide.

Une autre fonction utile est dir(), qui liste les attributs et méthodes disponibles sur un objet. (Remarque : les attributs et méthodes sont des caractéristiques et des actions disponibles sur un objet — nous en apprendrons davantage au chapitre 43. Nous apprendrons aussi à importer des modules au chapitre 22. Cet exemple montre comment le REPL aide à explorer les capacités de Python.)

>>> dir(str)

Cela affiche toutes les méthodes disponibles pour les objets de type chaîne de caractères.

1.3.6) Quand le REPL est-il le plus utile ?

Le REPL excelle pour :

1. L'apprentissage et l'exploration : lorsque vous apprenez un nouveau concept, le REPL vous permet d'expérimenter immédiatement sans créer de fichiers.

2. Tester de petits extraits de code : avant d'ajouter du code à votre programme, vous pouvez le tester dans le REPL pour vérifier qu'il fonctionne comme prévu.

3. Calculs rapides : le REPL est une calculatrice puissante toujours disponible.

4. Débogage : lorsque votre programme ne fonctionne pas, vous pouvez utiliser le REPL pour tester individuellement des parties de votre code.

5. Explorer des bibliothèques : en découvrant une nouvelle bibliothèque, vous pouvez l'importer dans le REPL et essayer ses fonctions de manière interactive.

Cependant, le REPL a des limites. Le code que vous écrivez dans le REPL disparaît lorsque vous le fermez — il n'y a aucun moyen de sauvegarder votre session REPL sous forme de programme. Pour tout code que vous voulez conserver et exécuter à plusieurs reprises, vous devrez créer des fichiers de script, ce que nous verrons dans la section suivante.

1.3.7) Quitter le REPL

Lorsque vous avez terminé avec le REPL, vous pouvez le quitter de plusieurs façons :

>>> exit()

Ou :

>>> quit()

Ou utiliser des raccourcis clavier :

• Windows : appuyez sur Ctrl + Z, puis Entrée
• macOS/Linux : appuyez sur Ctrl + D

Après la sortie, vous revenez à votre invite de commande ou terminal habituel.

1.4) Créer et exécuter des fichiers de script Python

Le REPL est excellent pour l'expérimentation et les tests rapides, mais que faire si vous voulez sauvegarder votre code et l'exécuter plus tard ? Et si vous voulez écrire un programme plus long avec des dizaines ou des centaines de lignes ? Pour ces situations, vous avez besoin de fichiers de script — des fichiers permanents contenant du code Python que vous pouvez modifier, sauvegarder et exécuter à volonté.

Bien que le REPL soit excellent pour l'expérimentation, la majorité de la programmation en Python se fait via des fichiers de script — des fichiers texte contenant du code Python qui peuvent être sauvegardés, modifiés et exécutés plusieurs fois. Dans cette section, vous allez apprendre à créer votre premier script Python et à l'exécuter depuis la ligne de commande.

1.4.1) Qu'est-ce qu'un script Python ?

Un script Python est simplement un fichier texte contenant du code Python, enregistré avec l'extension .py. Contrairement au code tapé dans le REPL, les fichiers de script :

• Sont permanents — vous pouvez les sauvegarder et les exécuter plus tard
• Peuvent être modifiés facilement
• Peuvent contenir autant de code que nécessaire
• Peuvent être partagés avec d'autres
• Peuvent être exécutés automatiquement ou selon un planning

Pensez à un fichier de script comme à une recette que vous notez, tandis que le REPL est plutôt comme cuisiner en improvisant la recette au fur et à mesure. Les deux ont leur utilité, mais pour quoi que ce soit de substantiel, vous voudrez un fichier de script.

1.4.2) Choisir un éditeur de texte

Pour créer des scripts Python, vous avez besoin d'un éditeur de texte. N'utilisez pas de traitement de texte comme Microsoft Word ou Google Docs — ils ajoutent une mise en forme que Python ne peut pas comprendre.

Bonnes options pour les débutants :

1. IDLE : livré avec Python. Simple et conçu pour l'apprentissage.

   • Sous Windows : recherchez "IDLE" dans le menu Démarrer
   • Sous macOS/Linux : tapez idle3 dans le terminal

2. Visual Studio Code (VS Code) : gratuit, puissant et largement utilisé par les professionnels. Excellent support de Python via des extensions.

   • Téléchargement : https://code.visualstudio.com/

3. PyCharm Community Edition : un IDE (Integrated Development Environment, environnement de développement intégré) complet, spécialement pour Python.

   • Téléchargement : https://www.jetbrains.com/pycharm/

4. Notepad++ (Windows uniquement) : léger et simple.

   • Téléchargement : https://notepad-plus-plus.org/

5. Sublime Text : rapide et élégant, avec un bon support de Python.

   • Téléchargement : https://www.sublimetext.com/

Pour ce livre, nous utiliserons des exemples simples qui fonctionnent avec n'importe quel éditeur de texte. Choisissez l'éditeur qui vous semble le plus confortable.

1.4.3) Créer votre premier script Python

Créons un script Python simple qui affiche des messages de salutation.

Étape 1 : Créer un nouveau fichier

Ouvrez l'éditeur de texte de votre choix et créez un nouveau fichier. Enregistrez-le sous le nom hello.py dans un emplacement dont vous vous souviendrez (par exemple votre Bureau ou un dossier dédié aux projets Python).

Important : l'extension .py est cruciale. Elle indique à votre système d'exploitation et à votre éditeur de texte qu'il s'agit d'un fichier Python.

Étape 2 : Écrire votre code

Tapez le code suivant dans votre fichier :

# hello.py
# My first Python script
 
print("Hello, World!")
print("Welcome to Python programming!")

Les lignes qui commencent par # sont des commentaires — des notes pour les humains qui lisent le code. Python les ignore complètement. Les commentaires vous aident à vous souvenir de ce que fait votre code et aident les autres à comprendre votre travail. Nous explorerons les commentaires plus en détail au chapitre 2.

Étape 3 : Sauvegarder le fichier

Sauvegardez le fichier. Assurez-vous qu'il est enregistré sous le nom hello.py, et non hello.py.txt ou avec une autre extension.

Voyons ce que fait ce code :

• print("Hello, World!") indique à Python d'afficher le texte "Hello, World!" à l'écran.
• print("Welcome to Python programming!") affiche un autre message.

1.4.4) Exécuter votre script depuis la ligne de commande

Maintenant que vous avez créé votre script, exécutons-le.

Étape 1 : Ouvrir votre ligne de commande/terminal

• Windows : ouvrez l'invite de commandes
• macOS/Linux : ouvrez le Terminal

Étape 2 : Naviguer jusqu'à l'emplacement de votre script

Utilisez la commande cd (change directory) pour vous rendre à l'emplacement où vous avez sauvegardé hello.py. Par exemple, si vous l'avez enregistré sur votre Bureau :

Windows :

cd Desktop

macOS/Linux :

cd ~/Desktop

Si vous obtenez une erreur comme "No such file or directory" lorsque vous essayez d'exécuter votre script, vous êtes probablement dans le mauvais dossier. Utilisez la commande cd pour vous rendre là où vous avez sauvegardé votre script.

Pour vérifier que vous êtes au bon endroit, vous pouvez lister les fichiers :

Windows :

dir

macOS/Linux :

ls

Vous devriez voir hello.py dans la liste.

Étape 3 : Exécuter votre script

Windows :

python hello.py

macOS/Linux :

python3 hello.py

Vous devriez voir la sortie :

Hello, World!
Welcome to Python programming!

Félicitations ! Vous venez de créer et d'exécuter votre premier script Python.

1.4.5) Comprendre l'exécution d'un script

Lorsque vous exécutez un script Python, voici ce qui se passe :

1. Vous tapez la commande pour exécuter votre script
2. Votre système d'exploitation lance l'interpréteur Python
3. L'interpréteur lit l'ensemble de votre fichier de script
4. Il vérifie les erreurs de syntaxe (des erreurs dans la manière dont vous avez écrit le code)
5. S'il y a des erreurs, il affiche un message d'erreur et s'arrête
6. S'il n'y a pas d'erreurs, il exécute votre code ligne par ligne, de haut en bas
7. Toute sortie (provenant des instructions print()) est affichée
8. Lorsque le script se termine, vous revenez à votre ligne de commande

1.4.6) Un exemple plus complexe

Créons un script légèrement plus complexe qui illustre plusieurs concepts. Commençons par ajouter un exemple intermédiaire qui introduit les variables plus en douceur :

# simple_variable.py
# Using a variable for the first time
 
message = "Hello, Python!"
print(message)

Sortie :

Hello, Python!

Cela fait le lien entre les simples instructions print et les exemples plus complexes. Voyons maintenant un script avec plusieurs variables :

# student_info.py
# A script that uses variables and multiple print statements
 
name = "Alice"
age = 25
city = "New York"
 
print("Student Information")
print("-------------------")
print("Name:", name)
print("Age:", age)
print("City:", city)

Enregistrez ce fichier sous le nom student_info.py et exécutez-le :

Windows :

python student_info.py

macOS/Linux :

python3 student_info.py

Sortie :

Student Information
-------------------
Name: Alice
Age: 25
City: New York

Ce script montre :

• La création de variables (nous en apprendrons davantage sur les variables au chapitre 3)
• L'utilisation de plusieurs instructions print()
• L'affichage à la fois de texte littéral et de valeurs de variables

1.4.7) Bonnes pratiques pour les fichiers de script

Même à ce stade précoce, il est bon de prendre quelques habitudes :

1. Utilisez des noms de fichiers explicites : nommez vos fichiers en fonction de ce qu'ils font. student_info.py est préférable à test.py ou program1.py, car vous vous souviendrez de ce qu'il fait lorsque vous le verrez dans une liste de fichiers dans six mois.

2. Gardez vos scripts organisés : créez un dossier dédié pour vos projets Python. Ne dispersez pas vos scripts partout sur votre ordinateur. Cela rendra plus simple la recherche de votre travail et gardera vos fichiers organisés.

3. Ajoutez des commentaires : commencez chaque script par un commentaire expliquant ce qu'il fait. Cela vous aide à vous en souvenir plus tard et aide les autres à comprendre votre code.

4. Un script, un objectif : chaque script devrait accomplir une tâche principale. N'essayez pas d'entasser plusieurs tâches sans rapport dans un seul fichier. Cela rend votre code plus facile à comprendre et à maintenir.

5. Testez fréquemment : exécutez votre script souvent pendant que vous l'écrivez. N'attendez pas d'avoir écrit 100 lignes pour tester — testez après chaque quelques lignes. Cela vous aide à détecter les erreurs tôt, lorsqu'elles sont plus faciles à corriger.

1.5) Un premier aperçu des erreurs et des tracebacks

Les erreurs font naturellement partie de la programmation. Tous les programmeurs, des débutants aux experts, rencontrent des erreurs régulièrement. Apprendre à lire et à comprendre les messages d'erreur est une compétence cruciale qui vous aidera à corriger rapidement les problèmes et à devenir un programmeur plus confiant.

1.5.1) Types d'erreurs

Python distingue deux grandes catégories d'erreurs :

Erreurs de syntaxe (Syntax Errors) : des erreurs dans la manière dont vous avez écrit le code — des violations des règles de grammaire de Python. Python les détecte avant d'exécuter votre code. Pensez aux erreurs de syntaxe comme à des fautes de grammaire dans un texte — Python ne peut même pas comprendre ce que vous essayez de dire.

Exceptions : des erreurs qui se produisent pendant que votre code s'exécute. La syntaxe est correcte, mais quelque chose se passe mal durant l'exécution. Les exceptions sont comme des problèmes à l'exécution — Python comprend vos instructions, mais ne peut pas les réaliser.

Explorons ces deux types avec des exemples.

1.5.2) Erreurs de syntaxe

Une erreur de syntaxe survient lorsque vous écrivez du code qui ne respecte pas les règles de Python. Python ne peut même pas commencer à exécuter votre code parce qu'il ne comprend pas ce que vous avez écrit.

Exemple 1 : Deux-points manquant

Créez un fichier appelé syntax_error1.py :

# syntax_error1.py
# This code has a syntax error
 
if 5 > 3
    print("Five is greater than three")

Lorsque vous essayez de l'exécuter :

python syntax_error1.py

Vous verrez :

  File "syntax_error1.py", line 4
    if 5 > 3
            ^
SyntaxError: expected ':'

Python vous indique plusieurs choses :

• Quel fichier pose problème : syntax_error1.py
• Quelle ligne pose problème : ligne 4
• Où sur cette ligne se situe le problème : le ^ pointe l'emplacement
• Quel type d'erreur : SyntaxError
• Une description utile : expected ':'

Le problème est que les instructions if en Python doivent se terminer par un deux-points (:). Le code correct est :

# syntax_error1_fixed.py
# Fixed version
 
if 5 > 3:
    print("Five is greater than three")

Sortie :

Five is greater than three

Exemple 2 : Guillemets non assortis

# syntax_error2.py
# Another syntax error example
 
message = "Hello, World!'
print(message)

L'exécution donne :

  File "syntax_error2.py", line 4
    message = "Hello, World!'
              ^
SyntaxError: unterminated string literal (detected at line 4)

Le problème est que la chaîne commence par un guillemet double (") mais se termine par un guillemet simple ('). Python exige des guillemets assortis. Corrigez en utilisant des guillemets correspondants :

# syntax_error2_fixed.py
# Fixed version
 
message = "Hello, World!"
print(message)

Sortie :

Hello, World!

1.5.3) Exceptions à l'exécution

Les exceptions à l'exécution (ou simplement "exceptions") se produisent lorsque votre code est syntaxiquement correct, mais que quelque chose se passe mal pendant l'exécution.

Exemple 1 : NameError

# name_error.py
# This code will cause a NameError
 
print(greeting)

Lorsque vous exécutez :

python name_error.py

Vous verrez :

Traceback (most recent call last):
  File "name_error.py", line 4, in <module>
    print(greeting)
          ^^^^^^^^
NameError: name 'greeting' is not defined

Ceci s'appelle un traceback. Décomposons-le :

• "Traceback (most recent call last):" indique que ce qui suit est un traceback qui montre où l'erreur s'est produite.
• Informations de fichier et de ligne : File "name_error.py", line 4, in <module> vous dit quel fichier et quelle ligne ont causé l'erreur.
• Le code problématique : print(greeting) montre la ligne exacte qui a échoué.
• Type d'erreur : NameError indique le type d'erreur.
• Description de l'erreur : name 'greeting' is not defined explique le problème — vous essayez d'utiliser une variable qui n'existe pas.

Pour corriger cela, vous devez définir la variable avant de l'utiliser :

# name_error_fixed.py
# Fixed version
 
greeting = "Hello!"
print(greeting)

Sortie :

Hello!

Exemple 2 : TypeError

# type_error.py
# This code will cause a TypeError
 
number = 5
text = "The number is "
result = text + number
print(result)

L'exécution produit :

Traceback (most recent call last):
  File "type_error.py", line 6, in <module>
    result = text + number
             ~~~~~^~~~~~~~
TypeError: can only concatenate str (not "int") to str

Le message d'erreur vous indique que vous ne pouvez pas additionner (concaténer) directement une chaîne de caractères et un entier. Python ne sait pas si vous voulez faire une addition mathématique ou une concaténation de chaînes.

Pour corriger cela, convertissez le nombre en chaîne :

# type_error_fixed.py
# Fixed version
 
number = 5
text = "The number is "
result = text + str(number)
print(result)

Sortie :

The number is 5

Exemple 3 : ZeroDivisionError

Que se passe-t-il si vous essayez de diviser par zéro ?

# zero_division.py
# This code will cause a ZeroDivisionError
 
result = 10 / 0
print(result)

L'exécution produit :

Traceback (most recent call last):
  File "zero_division.py", line 4, in <module>
    result = 10 / 0
             ~~~^~~
ZeroDivisionError: division by zero

Cette erreur est explicite : vous ne pouvez pas diviser par zéro. C'est mathématiquement indéfini, donc Python déclenche une erreur.

1.5.4) Lire efficacement les tracebacks

Quand vous rencontrez un traceback, lisez-le de bas en haut. Nous le lisons de bas en haut car la ligne du bas montre ce qui s'est mal passé (le type d'erreur et le message), tandis que les lignes au-dessus montrent la séquence d'appels de fonctions qui ont mené à l'erreur. Pour des programmes simples comme les nôtres, la ligne du bas vous dit tout ce que vous devez savoir.

1. Commencez par le bas : regardez d'abord le type d'erreur et le message.
2. Comprenez l'erreur : que vous dit Python sur ce qui s'est mal passé ?
3. Trouvez l'emplacement : repérez le fichier et le numéro de ligne où l'erreur s'est produite.
4. Examinez le code : regardez cette ligne dans votre fichier.
5. Remontez si nécessaire : parfois, le problème se trouve en réalité sur une ligne avant celle que Python indique.

1.5.5) Erreurs courantes chez les débutants

Voici quelques erreurs que vous rencontrerez probablement en apprenant Python :

Erreurs d'indentation :

Python utilise l'indentation (espaces ou tabulations au début des lignes) pour définir des blocs de code. Une indentation incorrecte provoque des erreurs :

# indentation_error.py
# Incorrect indentation
 
print("First line")
    print("Second line")  # This line is incorrectly indented

Erreur :

  File "indentation_error.py", line 5
    print("Second line")
    ^
IndentationError: unexpected indent

Fautes d'orthographe :

Python distingue les majuscules et les minuscules. Print n'est pas la même chose que print :

# spelling_error.py
# Incorrect capitalization
 
Print("Hello")  # Should be print, not Print

Erreur :

Traceback (most recent call last):
  File "spelling_error.py", line 4, in <module>
    Print("Hello")
    ^^^^^
NameError: name 'Print' is not defined

Parenthèses manquantes :

En Python 3, print nécessite des parenthèses :

# missing_parentheses.py
# Missing parentheses
 
print "Hello"  # Should be print("Hello")

Erreur :

  File "missing_parentheses.py", line 4
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Remarquez à quel point le message d'erreur de Python est utile ici — il suggère même la correction !

1.5.6) Stratégies pour gérer les erreurs

Lorsque vous rencontrez une erreur :

1. Ne paniquez pas : les erreurs sont normales. Tous les programmeurs en voient constamment.

2. Lisez attentivement le message d'erreur : les messages d'erreur de Python sont généralement utiles. Ils vous indiquent ce qui s'est mal passé et où.

3. Vérifiez le numéro de ligne : allez à la ligne indiquée par Python et cherchez le problème.

4. Regardez les lignes voisines : parfois, l'erreur se trouve en réalité sur la ligne qui précède celle que Python signale.

5. Cherchez les erreurs courantes : les deux-points manquants, les guillemets non assortis, l'indentation incorrecte et les fautes de frappe sont très fréquents.

6. Testez de petits changements : corrigez un seul élément à la fois et testez après chaque modification.

7. Utilisez le REPL : si vous n'êtes pas sûr de quelque chose, testez-le d'abord dans le REPL.

8. Recherchez l'erreur : si vous ne comprenez pas un message d'erreur, recherchez-le en ligne. Vous trouverez souvent des explications et des solutions.

1.5.7) Un exemple complet avec erreur et correction

Voyons un script contenant plusieurs erreurs et corrigeons-le étape par étape. Ce programme est conçu pour afficher des informations sur un étudiant et calculer son âge dans 10 ans :

Version originale (avec erreurs) :

# buggy_student.py
# This program has several errors
 
student_name = "Alice
student_age = 25
 
print("Name:", student_name)
print("Age:" student_age)
print("In 10 years, you will be", student_age + "10")

L'exécution produit plusieurs erreurs. Corrigeons-les une par une :

Erreur 1 : chaîne non terminée

  File "buggy_student.py", line 4
    student_name = "Alice
                   ^
SyntaxError: unterminated string literal (detected at line 4)

Correction : ajoutez le guillemet fermant :

student_name = "Alice"

Après avoir corrigé l'erreur 1, nous obtenons l'erreur 2 : virgule manquante

  File "buggy_student.py", line 8
    print("Age:" student_age)
                 ^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Correction : ajoutez une virgule entre la chaîne et la variable :

print("Age:", student_age)

Après avoir corrigé l'erreur 2, nous obtenons l'erreur 3 : erreur de type

Traceback (most recent call last):
  File "buggy_student.py", line 9, in <module>
    print("In 10 years, you will be", student_age + "10")
                                      ~~~~~~~~~~~~^~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Correction : convertissez "10" en entier :

print("In 10 years, you will be", student_age + 10)

Version finale corrigée :

# buggy_student_fixed.py
# Fixed version of the program
 
student_name = "Alice"
student_age = 25
 
print("Name:", student_name)
print("Age:", student_age)
print("In 10 years, you will be", student_age + 10)

Sortie :

Name: Alice
Age: 25
In 10 years, you will be 35

Cet exemple montre que la correction des erreurs est souvent un processus itératif. Vous corrigez une erreur, exécutez à nouveau le code, puis découvrez la suivante. C'est tout à fait normal.

1.6) Quand utiliser le shell interactif et quand utiliser des fichiers de script

Maintenant que vous avez appris à la fois le REPL et les fichiers de script, vous vous demandez peut-être quand utiliser l'un ou l'autre. Les deux sont des outils précieux, et les programmeurs Python expérimentés utilisent régulièrement les deux. Comprendre quand utiliser chaque outil vous rendra plus efficace.

1.6.1) Utilisez le shell interactif (REPL) lorsque :

1. Vous apprenez de nouveaux concepts

Lorsque vous apprenez quelque chose de nouveau, le REPL fournit un retour immédiat :

>>> # Testing string methods
>>> text = "hello world"
>>> text.upper()
'HELLO WORLD'
>>> text.title()
'Hello World'
>>> text.capitalize()
'Hello world'

Vous pouvez expérimenter avec différentes méthodes et voir les résultats instantanément sans créer de fichiers.

2. Vous testez de petits extraits de code

Avant d'ajouter du code à votre programme, testez-le dans le REPL :

>>> # Testing a calculation
>>> price = 19.99
>>> quantity = 3
>>> total = price * quantity
>>> total
59.97
>>> # Looks good, now I can add this to my script

3. Vous faites des calculs rapides

Le REPL est toujours disponible comme calculatrice :

>>> # How many seconds in a day?
>>> 24 * 60 * 60
86400
>>> # What's 15% of 250?
>>> 250 * 0.15
37.5

4. Vous déboguez

Lorsque votre script ne fonctionne pas, utilisez le REPL pour tester des parties individuelles :

>>> # My script isn't working. Let me test this part:
>>> numbers = [1, 2, 3, 4, 5]
>>> sum(numbers) / len(numbers)
3.0
>>> # This works, so the problem must be elsewhere

Remarque : nous apprendrons les listes (lists) au chapitre 13. Cet exemple montre comment le REPL aide à tester des extraits de code.

1.6.2) Utilisez des fichiers de script lorsque :

1. Vous écrivez des programmes que vous voulez conserver

Tout ce que vous voulez sauvegarder et réexécuter devrait se trouver dans un fichier de script :

# temperature_converter.py
# A program to convert Fahrenheit to Celsius
 
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5/9
print("Temperature:", fahrenheit, "°F is", round(celsius, 1), "°C")

Sortie :

Temperature: 98.6 °F is 37.0 °C

Vous pouvez exécuter ce script chaque fois que vous en avez besoin, et vous pouvez le modifier plus tard.

2. Vous écrivez des programmes multi-lignes

Bien que vous puissiez écrire du code multi-lignes dans le REPL, c'est peu pratique pour quelque chose de substantiel. Utilisez un fichier de script :

# grade_calculator.py
# Calculate final grade from multiple scores
 
homework = 85
midterm = 78
final = 92
 
# Calculate weighted average
final_grade = (homework * 0.3) + (midterm * 0.3) + (final * 0.4)
 
print("Final Grade:", final_grade)

Sortie :

Final Grade: 85.3

3. Vous partagez du code avec d'autres

Les fichiers de script peuvent facilement être partagés, contrairement aux sessions REPL :

# greeting.py
# A simple greeting program
 
name = input("What is your name? ")
print("Hello,", name + "! Welcome to Python.")

Remarque : nous apprendrons la fonction input() au chapitre 2. Cet exemple montre comment les scripts peuvent être partagés.

Vous pouvez envoyer ce fichier à quelqu'un d'autre, et il pourra l'exécuter sur son ordinateur.

4. Vous créez des outils réutilisables

Si vous créez quelque chose que vous utiliserez à plusieurs reprises, faites-en un script :

# file_counter.py
# Count files in a directory
 
import os
 
directory = "."  # Current directory
files = [f for f in os.listdir(directory) if os.path.isfile(f)]
print("Number of files:", len(files))

Remarque : nous apprendrons à importer des modules au chapitre 22 et les compréhensions de listes au chapitre 34. Cet exemple montre comment les scripts peuvent être des outils réutilisables.

5. Vous développez une logique complexe

Pour tout ce qui implique plusieurs fonctions (functions), classes ou une logique complexe, utilisez des fichiers de script :

# password_checker.py
# Check password strength
 
def check_password_strength(password):
    """Check if a password meets basic requirements."""
    if len(password) < 8:
        return "Too short"
    if not any(c.isupper() for c in password):
        return "Needs uppercase letter"
    if not any(c.isdigit() for c in password):
        return "Needs number"
    return "Strong password"
 
# Test the function
test_password = "MyPass123"
result = check_password_strength(test_password)
print("Password '" + test_password + "':", result)

Sortie :

Password 'MyPass123': Strong password

Remarque : nous apprendrons les fonctions (functions) au chapitre 19. Cet exemple montre comment les scripts gèrent une logique complexe.

6. Vous automatisez des tâches

Les scripts sont parfaits pour l'automatisation :

# backup_reminder.py
# Remind user to backup files
 
import datetime
 
today = datetime.date.today()
day_of_week = today.strftime("%A")
 
if day_of_week == "Friday":
    print("Don't forget to backup your files!")
else:
    print("Backup reminder: Next backup on Friday")

Remarque : nous apprendrons le module datetime au chapitre 39. Cet exemple montre comment les scripts peuvent automatiser des tâches.

1.6.3) Un flux de travail pratique

Les programmeurs Python professionnels utilisent généralement le REPL et les fichiers de script de manière complémentaire :

Exemple de flux de travail :

1. Explorer dans le REPL : essayer un nouveau concept ou tester un calcul
2. Prototyper dans le REPL : construire une petite version fonctionnelle
3. Passer au script : une fois que cela fonctionne, le mettre dans un fichier de script
4. Étendre dans le script : ajouter plus de fonctionnalités, de la gestion d'erreurs, etc.
5. Déboguer avec le REPL : si quelque chose se casse, tester des parties dans le REPL
6. Finaliser le script : terminer, tester et sauvegarder votre programme

1.6.4) Un exemple concret

Voyons ce flux de travail en action. Supposons que vous vouliez écrire un programme qui calcule l'aire d'un cercle.

Étape 1 : Explorer dans le REPL

>>> # What's the formula? Area = π * r²
>>> # Let me use a simple approximation for π
>>> 3.14159 * 5 * 5
78.53975
>>> # Looks right!

Étape 2 : Créer un script

Maintenant que vous savez que cela fonctionne, créez circle_area.py :

# circle_area.py
# Calculate the area of a circle
 
radius = 5
pi = 3.14159
area = pi * radius * radius
 
print("Radius:", radius)
print("Area:", area)

Sortie :

Radius: 5
Area: 78.53975

Étape 3 : Améliorer le script

Faites-le fonctionner avec différents rayons :

# circle_area_enhanced.py
# Calculate area for multiple circles
 
radii = [3, 5, 7, 10]
pi = 3.14159
 
for radius in radii:
    area = pi * radius * radius
    print("Circle with radius", radius, "has area", round(area, 2))

Sortie :

Circle with radius 3 has area 28.27
Circle with radius 5 has area 78.54
Circle with radius 7 has area 153.94
Circle with radius 10 has area 314.16

Remarque : nous apprendrons les boucles for (for loops) au chapitre 11. Au chapitre 2, nous apprendrons comment rendre cela interactif en obtenant une saisie de l'utilisateur.

Ce flux de travail — expérimenter dans le REPL, puis formaliser dans un script — est la manière dont de nombreux programmes Python sont développés.

1.6.5) Points clés à retenir

Forces du REPL :

• Retour immédiat
• Idéal pour l'apprentissage
• Parfait pour les tests rapides
• Excellent pour l'exploration
• Aucun fichier à gérer

Limites du REPL :

• Le code n'est pas sauvegardé
• Peu pratique pour le code multi-lignes
• Difficile à partager
• Pas adapté aux programmes complexes

Forces des fichiers de script :

• Le code est sauvegardé de façon permanente
• Faciles à modifier et à faire évoluer
• Peuvent être partagés avec d'autres
• Adaptés aux programmes complexes
• Peuvent être exécutés plusieurs fois
• Peuvent être automatisés

Limites des fichiers de script :

• Nécessitent de créer et gérer des fichiers
• Nécessitent une exécution pour voir les résultats
• Plus de « lourdeur » pour des tests très rapides

La meilleure approche est d'utiliser les deux : le REPL pour l'apprentissage, les tests et l'exploration, et les fichiers de script pour tout ce que vous voulez conserver, partager ou exécuter à plusieurs reprises.

1.7) Quelle version de Python ce livre utilise (et pourquoi c'est important)

Python a beaucoup évolué au fil des ans, et différentes versions peuvent se comporter différemment. Comprendre les versions de Python vous aidera à éviter la confusion et à vous assurer que votre code fonctionne comme prévu.

Vous vous demandez peut-être pourquoi nous passons du temps sur les versions de Python. La raison est simple : vous rencontrerez du code Python en ligne, dans des tutoriels et dans la documentation. Comprendre les versions vous aide à reconnaître quand un code est obsolète et à éviter la confusion lorsque quelque chose ne fonctionne pas comme prévu.

1.7.1) Python 2 vs Python 3

La division la plus importante de l'histoire de Python est celle entre Python 2 et Python 3.

Python 2 a été publié en 2000 et a été la version dominante pendant de nombreuses années. Cependant, il avait certains problèmes de conception qui ne pouvaient pas être corrigés sans casser le code existant.

Python 3 a été publié en 2008 comme une refonte majeure qui corrigeait ces problèmes. Cependant, il n'était pas rétrocompatible avec Python 2, ce qui signifie que le code écrit pour Python 2 ne fonctionnait souvent pas en Python 3 sans modifications.

Pendant de nombreuses années, les deux versions ont coexisté. Cependant, Python 2 est arrivé en fin de vie le 1er janvier 2020. Cela signifie :

• Plus aucune mise à jour ni correctif de sécurité pour Python 2
• Tout le nouveau développement Python utilise Python 3
• Toutes les grandes bibliothèques sont passées à Python 3
• Apprendre Python 2 aujourd'hui n'est pas recommandé

Ce livre utilise exclusivement Python 3. Tous les exemples de code sont écrits pour Python 3 et peuvent ne pas fonctionner en Python 2.

1.7.2) Les versions mineures de Python 3

Au sein de Python 3, il existe des versions mineures (3.6, 3.7, 3.8, 3.9, 3.10, 3.11, 3.12, etc.). Chaque version mineure ajoute de nouvelles fonctionnalités et améliorations tout en conservant la compatibilité ascendante avec les versions Python 3 précédentes.

Ce livre est écrit pour Python 3.11 et versions ultérieures, mais la plupart des exemples fonctionneront avec Python 3.8 et au-dessus.

Pour vérifier votre version de Python :

python --version  # Windows
python3 --version  # macOS/Linux

Vous devriez voir quelque chose comme :

Python 3.11.5

Si vous voyez :

Python 2.7.18

Vous exécutez Python 2, qui est obsolète. Installez Python 3 en suivant les instructions de la section 1.2.

1.7.3) Différences clés que vous pourriez rencontrer

Si vous lisez d'anciens tutoriels ou du code Python en ligne (en particulier dans des tutoriels plus anciens et des réponses Stack Overflow datant d'avant 2020), vous pourriez voir une syntaxe qui ne fonctionne pas en Python 3. Voici les différences les plus courantes :

1. L'instruction print vs la fonction print

Python 2 :

print "Hello, World!"  # No parentheses

Python 3 :

print("Hello, World!")  # Parentheses required

En Python 3, print est une fonction et nécessite des parenthèses. C'est la différence la plus visible.

2. Comportement de la division

Ces changements ont été introduits pour rendre Python plus cohérent et plus sûr. Par exemple, faire de print une fonction permet de l'utiliser comme n'importe quelle autre fonction, et faire en sorte que / effectue toujours une division flottante élimine une source fréquente de bugs.

Python 2 :

>>> 5 / 2
2  # Integer division
>>> 5.0 / 2
2.5  # Float division

Python 3 :

>>> 5 / 2
2.5  # Always float division
>>> 5 // 2
2  # Integer division (floor division)

En Python 3, / réalise toujours une division flottante. Utilisez // pour une division entière.

3. Fonction input()

Python 2 :

name = raw_input("Enter your name: ")  # Returns string
age = input("Enter your age: ")  # Evaluates input as Python code (dangerous!)

Python 3 :

name = input("Enter your name: ")  # Always returns string
age = int(input("Enter your age: "))  # Convert to int if needed

En Python 3, input() renvoie toujours une chaîne de caractères, ce qui est plus sûr et plus cohérent.

4. Chaînes de caractères et Unicode

Python 3 gère beaucoup mieux le texte (Unicode) que Python 2. Toutes les chaînes en Python 3 sont Unicode par défaut, ce qui facilite grandement la gestion de texte international.

1.7.4) Fonctionnalités selon les versions de Python 3

Différentes versions de Python 3 ont introduit des fonctionnalités différentes. Voici ce que vous devez savoir :

Python 3.6 (décembre 2016) :

• f-strings pour le formatage de chaînes (nous les utiliserons abondamment)

# f_string_example.py
name = "Alice"
print("Hello, " + name + "!")

Sortie :

Hello, Alice!

Remarque : nous apprendrons les f-strings au chapitre 6. Pour l'instant, nous utilisons une simple concaténation de chaînes avec +.

Python 3.8 (octobre 2019) :

• L'opérateur morse (:=, walrus operator) pour les expressions d'affectation (nous le verrons au chapitre 40)

Python 3.10 (octobre 2021) :

• Le pattern matching structurel avec match et case (nous le verrons au chapitre 12)

Python 3.11 (octobre 2022) :

• Messages d'erreur considérablement améliorés
• Meilleures performances
• Gestion améliorée des exceptions

Python 3.12 (octobre 2023) :

• Améliorations supplémentaires des performances
• Nouvelles fonctionnalités d'annotations de type
• Syntaxe des f-strings améliorée

1.7.5) Quelle version devriez-vous utiliser ?

Recommandation : utilisez Python 3.11 ou plus récent si possible. Voici pourquoi :

1. Meilleurs messages d'erreur : Python 3.11 a des messages d'erreur beaucoup plus clairs, plus utiles pour les débutants.

2. Meilleures performances : Python 3.11 est plus rapide que les versions antérieures.

3. Fonctionnalités modernes : vous aurez accès à toutes les fonctionnalités récentes de Python.

4. Pérennité : le code écrit pour Python 3.11 fonctionnera dans les versions futures.

Cependant, toute version Python 3.8 ou ultérieure conviendra pour apprendre avec ce livre. Les concepts de base restent les mêmes.

1.7.6) Vérifier la disponibilité des fonctionnalités

Si vous utilisez une version de Python plus ancienne et que vous rencontrez du code qui ne fonctionne pas, vous pouvez vérifier quelle version a introduit une fonctionnalité.

Par exemple, si vous utilisez Python 3.5 ou antérieur, vous devrez peut-être utiliser un ancien formatage de chaînes :

# format_example.py
# Works in all Python 3 versions
name = "Alice"
print("Hello, {}!".format(name))

Sortie :

Hello, Alice!

1.7.7) Rester à jour

Python publie une nouvelle version mineure environ une fois par an. Vous n'avez pas besoin de mettre à jour immédiatement, mais il est bon de rester raisonnablement à jour :

• Vérifiez les mises à jour tous les quelques mois
• Lisez les notes de version pour découvrir les nouvelles fonctionnalités
• Mettez à niveau quand c'est pratique, surtout pour les mises à jour de sécurité
• Testez votre code après une mise à niveau pour vérifier la compatibilité

Vous pouvez trouver les versions de Python et la documentation sur https://www.python.org/.

1.7.8) Compatibilité des versions dans ce livre

Tout au long de ce livre :

• Tous les exemples de code fonctionnent avec Python 3.11+
• La plupart des exemples fonctionnent avec Python 3.8+
• Les fonctionnalités spécifiques à une version sont clairement indiquées (par exemple, "Cela nécessite Python 3.10+")
• Des approches alternatives sont fournies lorsque c'est approprié pour les versions plus anciennes

Lorsque vous voyez du code dans ce livre, vous pouvez en toute confiance le taper dans Python 3.11 ou une version ultérieure et vous attendre à ce qu'il fonctionne exactement comme indiqué.

1.7.9) Une note sur le code Python 2 que vous pourriez trouver en ligne

Si vous cherchez de l'aide sur Python en ligne, vous pourriez tomber sur du code Python 2. Voici comment le reconnaître :

Signes d'un code Python 2 :

• print sans parenthèses : print "Hello"
• Fonction raw_input()
• Division qui produit des entiers : 5 / 2 donne 2
• Ancien formatage de chaînes : "Hello %s" % name
• Commentaires indiquant "Python 2" ou mentionnant la version 2.x

Que faire :

• Cherchez des alternatives Python 3
• Ajoutez "python 3" à vos recherches
• Vérifiez la date — tout ce qui date d'avant 2020 peut être en Python 2
• Utilisez la documentation officielle Python 3 : https://docs.python.org/3/

Félicitations ! Vous avez terminé le chapitre 1 et fait vos premiers pas avec Python. Vous savez maintenant :

• Ce qu'est Python et comment il fonctionne
• Comment installer Python et exécuter l'interpréteur
• Comment utiliser le shell interactif Python (REPL) pour l'expérimentation
• Comment créer et exécuter des fichiers de script Python
• Comment lire et comprendre les messages d'erreur et les tracebacks
• Quand utiliser le REPL et quand utiliser des fichiers de script
• Quelle version de Python utiliser et pourquoi cela compte

Vous êtes maintenant prêt à passer au chapitre 2, où vous écrirez vos premiers programmes Python complets, apprendrez la fonction print() en détail et commencerez à travailler avec la saisie utilisateur. Les bases que vous avez posées dans ce chapitre soutiendront tout ce que vous apprendrez par la suite.