# Apprendre Python de zéro : feuille de route, exemples de code et exercices pour devenir autonome

> Apprendre Python de zéro : installation, variables, chaînes, conditions, listes, boucles et gestion des erreurs, avec exercices et projets pour progresser.

- URL : https://guides-numeriques.fr/developpement/apprendre-python/
- Thématique : Développement web & mobile
- Mis à jour : 2026-09-26
- Formation associée : [Apprendre Python de zéro à expert - Avec projets](https://espritacademique.com/formations/apprendre-python-de-zero-a-expert-avec-projets-2026/)

## L'essentiel

- Pour apprendre Python, il suffit d'installer l'interpréteur Python depuis python.org et un éditeur comme Visual Studio Code : les deux sont gratuits.
- Les fondamentaux de Python sont les variables, les types de données, les chaînes de caractères, les conditions, les listes, les boucles et les fonctions.
- En Python, l'indentation n'est pas décorative : elle délimite les blocs de code, et une indentation incohérente provoque une erreur.
- La fonction input() renvoie toujours une chaîne de caractères : il faut la convertir avec int() ou float() avant tout calcul.
- Les projets courts, comme un jeu du nombre mystère ou un vérificateur de mot de passe, font davantage progresser que la lecture de cours théoriques.

**Apprendre Python** est l'une des meilleures portes d'entrée dans la programmation : sa syntaxe est lisible, il s'installe gratuitement en quelques minutes et il permet très vite d'automatiser des tâches concrètes, comme renommer des fichiers, traiter un export ou analyser des données. Avec une méthode structurée et des projets courts, les bases s'acquièrent en quelques semaines.

Cette feuille de route s'adresse aux débutants complets. Vous y trouverez l'installation de votre environnement, les notions à apprendre dans l'ordre avec des exemples de code commentés, des idées d'exercices Python, les erreurs que nous voyons le plus souvent en formation et le chemin à suivre ensuite selon votre objectif.

## Qu'est-ce que Python ?

Python est un langage de programmation généraliste, interprété et open source, apparu au début des années 1990. Il se distingue par une syntaxe épurée, où l'indentation structure le code. On l'utilise pour l'automatisation, l'analyse de données, l'intelligence artificielle, le développement web et les scripts système.

« Interprété » signifie que vous n'avez pas besoin de compiler votre programme : l'interpréteur Python lit votre fichier `.py` et l'exécute ligne par ligne. Vous écrivez, vous lancez, vous voyez le résultat.

Python est aussi livré avec une **bibliothèque standard** très riche (gestion des fichiers, des dates, du hasard, des fichiers CSV ou JSON) et un vaste écosystème de paquets tiers installables avec l'outil `pip`.

## Pourquoi apprendre Python ?

Python est polyvalent : un même langage vous sert dans des contextes très différents.

- **Automatiser des tâches répétitives** : renommer ou trier des centaines de fichiers, fusionner des fichiers CSV, envoyer des rapports.
- **Analyser des données** avec pandas, produire des graphiques avec matplotlib, remplacer des traitements Excel devenus trop lourds.
- **Récupérer des données sur le web** (web scraping) ou interroger des API.
- **Faire de l'intelligence artificielle** et du machine learning avec scikit-learn, PyTorch ou TensorFlow.
- **Créer des sites et des API** avec Django, Flask ou FastAPI.
- **Scripter des logiciels** : de nombreux outils, comme Blender, intègrent Python pour automatiser leurs fonctions.

Notre conseil : choisissez tôt un objectif concret. Apprendre « Python en général » sans but précis mène souvent à l'abandon, alors qu'un petit problème réel à résoudre donne une direction à chaque séance.

## Installer Python et VS Code

### Installer Python

Téléchargez le dernier installateur Python 3 depuis le site officiel [python.org](https://www.python.org/). Sous Windows, au premier écran de l'installation, **cochez la case « Add python.exe to PATH »** avant de cliquer sur Install Now. Oublier cette case est la cause numéro un des commandes Python « introuvables » dans le terminal.

Vérifiez ensuite l'installation en ouvrant un terminal (PowerShell sous Windows, Terminal sous macOS) :

```bash
python --version
```

Sous Windows, la commande `py --version` fonctionne aussi grâce au lanceur Python. Sous macOS et Linux, utilisez souvent `python3 --version`.

### Installer Visual Studio Code

Installez Visual Studio Code, puis ajoutez l'extension **Python** publiée par Microsoft depuis le panneau Extensions (Ctrl+Maj+X). Elle apporte la coloration syntaxique, l'autocomplétion, l'exécution d'un fichier avec le bouton lecture en haut à droite et le débogueur.

Créez un dossier de travail, par exemple `cours-python`, ouvrez-le dans VS Code (**Fichier > Ouvrir le dossier**) et créez un premier fichier `bonjour.py`.

## Apprendre Python pas à pas : les étapes


**Schéma — Apprendre Python pas à pas : les étapes clés**

1. **Premier script** : print() dans bonjour.py, exécuté dans VS Code
2. **Variables et types** : int, float, str, bool, input() et conversions
3. **Conditions** : if, elif, else et opérateurs de comparaison
4. **Gérer les erreurs** : try et except autour des conversions
5. **Listes et boucles** : append, indices, for et while
6. **Fonctions et modules** : def, return, modules random et os


### Étape 1 — Écrire et exécuter votre premier script Python

Dans `bonjour.py`, écrivez :

```python
# Mon premier script Python
print("Bonjour !")
print("2 + 3 =", 2 + 3)
```

Lancez-le avec le bouton d'exécution de VS Code, ou dans le terminal avec `python bonjour.py`. La fonction `print()` affiche du texte ou des valeurs. Tout ce qui suit un `#` est un **commentaire**, ignoré par Python : utilisez-le pour expliquer le pourquoi d'une ligne, pas pour paraphraser le code.

### Étape 2 — Comprendre les variables Python et les types de données

Une variable associe un nom à une valeur. En Python, pas besoin de déclarer le type : il est déduit de la valeur.

```python
prenom = "Alex"          # str : chaîne de caractères
age = 32                 # int : nombre entier
taille = 1.78            # float : nombre décimal
est_inscrit = True       # bool : booléen (True ou False)

print(type(age))         # <class 'int'>
```

Les noms de variables s'écrivent en minuscules avec des tirets bas (`prix_total`, `nombre_clients`), ne commencent jamais par un chiffre et ne contiennent ni espace ni tiret.

Pour rendre un script interactif, la fonction `input()` lit une saisie au clavier. Attention : elle renvoie **toujours une chaîne**. Il faut donc la convertir avant de calculer.

```python
annee_naissance = input("Votre année de naissance : ")
age = 2026 - int(annee_naissance)
print("Vous avez environ", age, "ans.")
```

Les fonctions de conversion à connaître sont `int()`, `float()`, `str()` et `bool()`.

### Étape 3 — Manipuler le texte et formater l'affichage

Les chaînes de caractères disposent de nombreuses **méthodes**, que l'on appelle avec un point :

```python
texte = "  apprendre python pas à pas  "

propre = texte.strip()                 # retire les espaces aux extrémités
print(propre.upper())                  # APPRENDRE PYTHON PAS À PAS
print(propre.title())                  # Apprendre Python Pas À Pas
print(propre.replace("pas à pas", "facilement"))

mots = propre.split(" ")               # ['apprendre', 'python', 'pas', 'à', 'pas']
print("-".join(mots))                  # apprendre-python-pas-à-pas
print(propre.count("pas"))             # 2
print(propre.startswith("apprendre"))  # True
print("2026".isdigit())                # True
```

Pour afficher des résultats propres, utilisez les **f-strings** : préfixez la chaîne d'un `f` et placez les variables entre accolades. Un format peut suivre le deux-points.

```python
produit = "Clavier"
prix = 49.9
quantite = 3
print(f"{quantite} x {produit} = {prix * quantite:.2f} €")  # 3 x Clavier = 149.70 €
```

La méthode `format()` produit le même résultat avec une syntaxe plus ancienne : `"{} coûte {:.2f} €".format(produit, prix)`. Vous la croiserez dans du code existant, mais privilégiez les f-strings.

### Étape 4 — Prendre des décisions avec if, elif et else

Les conditions exécutent un bloc selon qu'une expression est vraie ou fausse. Le bloc est défini par le **deux-points** et l'**indentation** (quatre espaces).

```python
note = float(input("Votre note sur 20 : "))

if note >= 16:
    print("Très bien")
elif note >= 12:
    print("Assez bien")
elif note >= 10:
    print("Admis")
else:
    print("Non admis")

age = 20
a_un_billet = True
if age >= 18 and a_un_billet:
    print("Accès autorisé")
```

Les opérateurs de comparaison sont `==`, `!=`, `<`, `>`, `<=` et `>=`. Les opérateurs logiques s'écrivent en toutes lettres : `and`, `or`, `not`. Python évalue les conditions dans l'ordre et s'arrête à la première vraie : placez donc les cas les plus restrictifs en premier.

### Étape 5 — Gérer les erreurs avec try et except

Que se passe-t-il si l'utilisateur tape « vingt » au lieu de « 20 » ? `int("vingt")` provoque une erreur `ValueError` et le script s'arrête. Le bloc `try` / `except` permet de réagir proprement :

```python
while True:
    saisie = input("Entrez votre âge : ")
    try:
        age = int(saisie)
        break
    except ValueError:
        print("Merci de saisir un nombre entier.")

print(f"Âge enregistré : {age}")
```

Précisez toujours le type d'erreur attendu (`ValueError`, `ZeroDivisionError`, `FileNotFoundError`) plutôt qu'un `except` nu, qui masquerait aussi les vrais bugs.

Pour comprendre un comportement inattendu, utilisez le **débogueur** de VS Code : cliquez dans la marge à gauche d'une ligne pour poser un point d'arrêt, puis lancez le script avec F5. L'exécution s'arrête sur la ligne et vous voyez la valeur de chaque variable.

### Étape 6 — Travailler avec les listes

Une liste range plusieurs valeurs dans un ordre donné. Les **indices** commencent à 0, et les indices négatifs partent de la fin.

```python
courses = ["tomates", "courgettes", "aubergines", "poivrons"]

print(courses[0])        # tomates
print(courses[-1])       # poivrons
print(courses[1:3])      # ['courgettes', 'aubergines'] (slice : fin exclue)
print(len(courses))      # 4

courses.append("oignons")    # ajoute à la fin
courses.remove("poivrons")   # retire par valeur
courses.sort()               # trie sur place
print("tomates" in courses)  # True

# Liste imbriquée : un tableau à deux dimensions
notes = [[12, 15], [9, 14], [18, 17]]
print(notes[2][0])       # 18
```

Les fonctions intégrées `len()`, `sum()`, `min()`, `max()` et `sorted()` s'appliquent directement aux listes de nombres : `sum(notes[0]) / len(notes[0])` calcule une moyenne.

### Étape 7 — Automatiser avec les boucles for et while

La boucle `for` parcourt une séquence ; la boucle `while` tourne tant qu'une condition est vraie.

```python
prix = [12.5, 8.0, 23.9]
total = 0
for p in prix:
    total += p
print(f"Total : {total:.2f} €")

for i in range(1, 6):        # 1, 2, 3, 4, 5
    if i == 3:
        continue             # saute ce tour
    print(i)

compte_a_rebours = 5
while compte_a_rebours > 0:
    print(compte_a_rebours)
    compte_a_rebours -= 1
print("Décollage !")
```

`break` sort immédiatement de la boucle, `continue` passe au tour suivant. La fonction `range(debut, fin)` génère une suite de nombres dont la borne de fin est exclue, un détail qui piège presque tous les débutants.

### Étape 8 — Organiser son code avec des fonctions et des modules

Une fonction regroupe des instructions sous un nom réutilisable. Un module est un fichier Python que l'on importe pour profiter de ses fonctions.

```python
import random
import os

def tirer_au_sort(participants):
    """Renvoie un gagnant choisi au hasard."""
    return random.choice(participants)

gagnant = tirer_au_sort(["Nina", "Omar", "Lou"])
print(f"Le gagnant est {gagnant}")

print(os.getcwd())                 # dossier courant
for nom in os.listdir("."):        # fichiers du dossier courant
    print(nom)
```

Le module `random` gère le hasard (`randint`, `choice`, `shuffle`), le module `os` interagit avec le système (dossiers, fichiers, chemins). La ligne entre triples guillemets sous `def` est une **docstring** : elle documente ce que fait la fonction.

> **Formation recommandée** : [Apprendre Python de zéro à expert - Avec projets](https://espritacademique.com/formations/apprendre-python-de-zero-a-expert-avec-projets-2026/) — 3h00 de vidéo, 69 €.

## Exercices Python : des projets pour progresser

Les exercices Python les plus formateurs sont de petits programmes complets. Voici un projet guidé qui mobilise presque toutes les notions vues : le jeu du nombre mystère.

```python
import random

nombre_mystere = random.randint(1, 100)
essais = 0
max_essais = 7

print("J'ai choisi un nombre entre 1 et 100.")

while essais < max_essais:
    saisie = input(f"Essai {essais + 1}/{max_essais} : ")
    try:
        proposition = int(saisie)
    except ValueError:
        print("Entrez un nombre entier.")
        continue

    essais += 1
    if proposition < nombre_mystere:
        print("C'est plus.")
    elif proposition > nombre_mystere:
        print("C'est moins.")
    else:
        print(f"Bravo, trouvé en {essais} essai(s) !")
        break
else:
    print(f"Perdu ! Le nombre était {nombre_mystere}.")
```

Remarquez le `else` rattaché au `while` : il s'exécute seulement si la boucle se termine sans `break`, c'est-à-dire quand le joueur a épuisé ses essais.

D'autres idées de projets, classées par difficulté :

| Projet | Notions travaillées | Niveau |
|---|---|---|
| Calculateur d'âge | `input()`, conversion, f-string | Débutant |
| Convertisseur de devises ou de températures | Variables, calculs, formatage | Débutant |
| Mention selon la note | `if`, `elif`, `else`, opérateurs logiques | Débutant |
| Vérificateur de mot de passe | Méthodes `isdigit()`, `isupper()`, boucles, `len()` | Intermédiaire |
| Liste de courses en console | Listes, `append`, `remove`, boucle `while` | Intermédiaire |
| Renommeur de fichiers | Module `os`, boucles, chaînes | Intermédiaire |
| Carnet de notes | Listes imbriquées, fonctions, moyennes | Intermédiaire |

Pour chaque projet, écrivez d'abord les étapes en français dans des commentaires, puis traduisez-les une par une en code. Cette méthode évite le syndrome de la page blanche.

## Bonnes pratiques pour écrire un script Python lisible

Un script qui fonctionne n'est pas forcément un bon script. Quelques habitudes, prises dès le début, rendent votre code plus facile à relire, à corriger et à réutiliser.

- **Suivez les conventions de la PEP 8**, le guide de style officiel : noms en minuscules avec tirets bas, quatre espaces d'indentation, lignes pas trop longues. L'extension Python de VS Code peut signaler les écarts.
- **Donnez des noms explicites** : `prix_ttc` plutôt que `p`, `liste_clients` plutôt que `l`. Le code se lit bien plus souvent qu'il ne s'écrit.
- **Découpez en fonctions courtes** qui font une seule chose, et regroupez les réglages (taux, chemins, limites) en haut du fichier sous forme de constantes en majuscules.
- **Protégez le point d'entrée** avec `if __name__ == "__main__":` : le code placé dessous ne s'exécute que si le fichier est lancé directement, pas lorsqu'il est importé comme module.
- **Isolez les dépendances de chaque projet** dans un environnement virtuel, créé avec `python -m venv .venv`, avant d'installer des paquets avec `pip`.
- **Testez au fur et à mesure** : exécutez votre script après chaque ajout de quelques lignes, plutôt qu'une seule fois à la fin.

## Les erreurs fréquentes quand on débute en Python

En formation, ces messages d'erreur reviennent systématiquement. Apprenez à les lire : Python indique le fichier, la ligne et le type d'erreur en dernière ligne du message.

| Message d'erreur | Cause | Solution |
|---|---|---|
| `IndentationError` | Indentation incohérente, mélange de tabulations et d'espaces | Utiliser quatre espaces partout (VS Code le fait par défaut) |
| `SyntaxError: expected ':'` | Deux-points oublié après `if`, `for`, `while` ou `def` | Ajouter le `:` en fin de ligne |
| `TypeError: can only concatenate str (not "int") to str` | Addition d'un texte et d'un nombre | Utiliser une f-string ou convertir avec `str()` |
| `ValueError: invalid literal for int()` | Conversion d'une saisie non numérique | Protéger la conversion avec `try` / `except` |
| `NameError: name 'x' is not defined` | Faute de frappe ou variable utilisée avant sa création | Vérifier l'orthographe et l'ordre des lignes |
| `IndexError: list index out of range` | Indice supérieur ou égal à la longueur de la liste | Rappel : le dernier indice vaut `len(liste) - 1` |
| Confusion entre `=` et `==` | `=` affecte une valeur, `==` compare | Utiliser `==` dans les conditions |
| `'python' n'est pas reconnu` (Windows) | Python absent du PATH | Réinstaller en cochant « Add python.exe to PATH » ou utiliser `py` |

## Après les bases : quelle spécialisation choisir ?

Une fois les fondamentaux maîtrisés, Python se décline en spécialités, chacune avec ses bibliothèques.


**Schéma — Après les bases : les spécialisations de Python**

Python :
- **Analyse de données** : pandas, requests, BeautifulSoup, matplotlib
- **Intelligence artificielle** : NumPy, scikit-learn, PyTorch ou TensorFlow
- **Bases de données** : sqlite3, SQLAlchemy
- **Développement web** : Django, Flask, FastAPI
- **Automatisation système** : os, pathlib, shutil, subprocess


| Objectif | Bibliothèques à apprendre | Étape suivante sur le site |
|---|---|---|
| Analyse de données et scraping | pandas, requests, BeautifulSoup, matplotlib | [Web scraping et analyse avec pandas](https://guides-numeriques.fr/data/web-scraping-python-pandas/) |
| Intelligence artificielle | NumPy, scikit-learn, PyTorch ou TensorFlow | [Machine learning et deep learning](https://guides-numeriques.fr/data/machine-learning-deep-learning/) |
| Bases de données | sqlite3, SQLAlchemy | [Apprendre SQL](https://guides-numeriques.fr/data/apprendre-sql/) |
| Développement web | Django, Flask, FastAPI | Bases HTML, CSS et JavaScript |
| Automatisation système | os, pathlib, shutil, subprocess | Scripts planifiés, outils en ligne de commande |

Quel que soit votre choix, prenez l'habitude de versionner vos scripts : [apprendre Git et GitHub](https://guides-numeriques.fr/developpement/git-github/) vous permettra de suivre vos modifications et de présenter vos projets. Si votre cible est plutôt le développement web côté navigateur, notre guide pour [apprendre JavaScript](https://guides-numeriques.fr/developpement/apprendre-javascript/) complète naturellement Python.

## Comment apprendre Python efficacement ?

Voici la feuille de route que nous recommandons pour passer de zéro à l'autonomie en scripting :

1. **Semaine 1** : installation, `print()`, variables, types, `input()` et conversions. Premier exercice : un calculateur d'âge.
2. **Semaine 2** : méthodes de chaînes, f-strings, opérateurs, conditions. Projet : une calculatrice de mentions.
3. **Semaine 3** : gestion des erreurs, débogueur, modules `random` et `os`, listes et slices. Projet : un vérificateur de mot de passe.
4. **Semaine 4** : boucles `for` et `while`, `break` et `continue`, fonctions. Projet : le jeu du nombre mystère, puis un renommeur de fichiers.
5. **Ensuite** : dictionnaires, lecture et écriture de fichiers, puis une spécialisation (data, web, automatisation).

Codez au moins trente minutes par jour plutôt que quatre heures le dimanche : la régularité fixe les automatismes. Et retapez les exemples au lieu de les copier-coller, c'est ainsi que la syntaxe s'imprime.

Pour suivre ce parcours de façon guidée, [la formation vidéo pour apprendre Python avec des projets guidés](https://espritacademique.com/formations/apprendre-python-de-zero-a-expert-avec-projets-2026/) d'EspritAcadémique condense les fondamentaux en trois heures, sans aucun prérequis. Elle couvre notamment :

- l'installation de Python et de Visual Studio Code, puis l'écriture et l'exécution de vos premiers scripts ;
- les variables, les types, la fonction `input()` et les conversions de données ;
- le traitement du texte (`split`, `join`, `replace`, méthodes `is…`) et l'affichage avec les f-strings ;
- les conditions, le débogueur et la gestion des erreurs avec `try` et `except` ;
- les modules `random` et `os`, les listes, les slices et les listes imbriquées ;
- les boucles `for` et `while`, consolidées par une série de onze projets guidés.

## En résumé

Pour apprendre Python, installez l'interpréteur et VS Code, puis progressez dans l'ordre : variables et types, chaînes et f-strings, conditions, gestion des erreurs, listes, boucles, fonctions et modules. Consolidez chaque notion par un petit projet complet, lisez attentivement les messages d'erreur et codez un peu chaque jour. En un mois de pratique régulière, vous écrirez des scripts utiles et pourrez choisir votre spécialisation.

## Sources et documentation officielle

- [Le tutoriel Python (documentation officielle Python)](https://docs.python.org/fr/3/tutorial/index.html)
- [Erreurs et exceptions (documentation officielle Python)](https://docs.python.org/fr/3/tutorial/errors.html)
- [Download Python (Python.org)](https://www.python.org/downloads/)
- [Getting Started with Python in VS Code (Visual Studio Code)](https://code.visualstudio.com/docs/python/python-tutorial)

## Questions fréquentes

### Combien de temps faut-il pour apprendre Python ?

Comptez quatre à six semaines, à raison de quelques heures par semaine, pour maîtriser les bases : variables, chaînes, conditions, listes, boucles, fonctions et gestion des erreurs. Devenir opérationnel dans un domaine précis, comme l'analyse de données avec pandas ou le développement web avec Django, demande ensuite quelques mois de pratique sur des projets réels.

### Python est-il un bon premier langage de programmation ?

Oui, c'est l'un des langages les plus recommandés pour débuter. Sa syntaxe est proche de l'anglais, sans accolades ni points-virgules, et il affiche des messages d'erreur plutôt explicites. Il permet d'obtenir rapidement des résultats utiles, comme automatiser une tâche ou traiter un fichier, ce qui aide à rester motivé pendant l'apprentissage.

### Peut-on apprendre Python sans être bon en maths ?

Oui. Pour les bases et l'automatisation, les mathématiques nécessaires se limitent aux quatre opérations et aux comparaisons. La programmation demande surtout de la logique : découper un problème en petites étapes. Les mathématiques deviennent importantes seulement pour certaines spécialités, comme le machine learning ou le calcul scientifique, que l'on aborde bien après les fondamentaux.

### Quelle version de Python faut-il installer ?

Installez la dernière version stable de Python 3 proposée sur le site officiel python.org. Python 2 n'est plus maintenu depuis 2020 et ne doit plus être utilisé pour apprendre. Les cours et exercices écrits pour Python 3 fonctionnent sur toutes les versions 3 récentes, les différences entre elles ne concernant pas les bases du langage.

### Quelle est la différence entre une liste et un tuple en Python ?

Une liste, écrite entre crochets, est modifiable : on peut ajouter, retirer ou remplacer des éléments. Un tuple, écrit entre parenthèses, est immuable : une fois créé, son contenu ne change plus. On utilise la liste pour une collection qui évolue, comme un panier, et le tuple pour des données fixes, comme des coordonnées.

### Faut-il apprendre Python ou JavaScript en premier ?

Tout dépend de votre objectif. Si vous visez le développement de sites web, JavaScript est indispensable car c'est le langage du navigateur. Si vous visez l'automatisation, l'analyse de données ou l'intelligence artificielle, Python est le meilleur point de départ. Les concepts de base étant les mêmes, apprendre le second langage sera ensuite beaucoup plus rapide.