Bibliothèque · Résumé et avis

Python Crash Course

D'Eric Matthes. L'initiation à Python la plus vendue au monde, écrite par un prof de lycée : les bases, puis trois vrais projets.

FR EN
Couverture de Python Crash Course, Eric Matthes

Python Crash Course

Python Crash Course: A Hands-On, Project-Based Introduction to Programming

6.5 /10

« Pas le meilleur livre sur Python : le meilleur premier livre, et c'est beaucoup plus rare. »

  • AuteurEric Matthes · « prof de maths au lycée pendant 25 ans »
  • VONo Starch Press, 2023 · 552 pages
  • Édition3ᵉ édition (2023), plus d'un million d'exemplaires
  • Fiche~10 min de lecture
Notation du livre sur 6 dimensionsIdées4,5/10Applicable7,5/10Lisibilité9/10Actualité7,5/10Exemples7,5/10Profondeur3/10

L'entrée en Python la plus vendue au monde : les bases, puis trois vrais projets (jeu, data viz, web).

Pourquoi ce livre

« Par où je commence ? » C'est la question qu'on me pose le plus souvent, et c'est la plus dure. Pas parce que les ressources manquent : parce qu'il y en a trop, et que la plupart noient le débutant sous tout ce qu'il n'a pas encore besoin de savoir. Python Crash Course est la réponse que le marché a donnée. Sa préface annonce plus d'un million d'exemplaires imprimés et des traductions dans plus de dix langues. Son éditeur en fait le guide le plus vendu au monde sur Python.

Je l'ai lu avec une double casquette. Celle du dev qui veut une recommandation fiable à donner. Et celle de quelqu'un qui passe ses soirées à construire des cours pour débutants : Eric Matthes était professeur de sciences, de maths et de programmation au lycée avant de devenir auteur à plein temps. Ce livre, c'est ce que des années de salle de classe produisent quand on les compresse en 552 pages. Ça s'étudie.

Les idées qui restent

Le livre fait 552 pages en deux moitiés : onze chapitres de bases, puis trois projets complets au choix. Voilà ce qui reste une fois refermé.

1Un cours « soigneusement trié », pas une encyclopédie

Un manuel pour débutants se juge à ce qu'il laisse de côté. Matthes explique dans sa préface que son objectif principal, en révisant le livre, est de le garder comme un cours d'introduction soigneusement trié. Concrètement, chaque édition coupe autant qu'elle ajoute. La 3ᵉ :

  • remplace unittest par pytest (l'outil de tests devenu le standard) ;
  • troque l'ancien open() contre pathlib (la manipulation de fichiers moderne) ;
  • abandonne Heroku pour Platform.sh (deux hébergeurs) ;
  • installe le débutant sur VS Code (un éditeur de code gratuit).

Les outils avancés (compréhensions de dictionnaires, décorateurs, métaclasses) peuvent attendre : pas parce que c'est inutile, parce que ce n'est pas le jour. Le tri, c'est ça, le vrai travail pédagogique : choisir l'ordre, le sous-ensemble, et assumer les coupes.

2Les variables sont des étiquettes, pas des boîtes

Presque tous les cours d'initiation expliquent qu'une variable est « une boîte qui contient une valeur ». Matthes corrige dès la page 18 : « cette image peut aider les premières fois, mais elle ne décrit pas fidèlement la façon dont Python représente les variables en interne. Il vaut bien mieux voir les variables comme des étiquettes qu'on colle sur des valeurs ».

La différence a l'air cosmétique, elle est fondamentale. Une boîte contient SA valeur, donc affecter devrait copier. En Python, affecter colle une étiquette de plus sur le même objet. Le jour où deux variables « partagent » mystérieusement une liste (vous modifiez l'une, l'autre change aussi), le modèle boîte s'effondre et le modèle étiquette explique tout.

Donner le bon modèle dès le chapitre 2, avant même que le piège soit possible : voilà ce qui sépare un cours pensé d'un cours récité.

3Les erreurs se provoquent exprès

Selon le livre, le premier chapitre fait introduire volontairement une faute de frappe dans son tout premier programme, pour regarder ce qui se passe. Casser le programme est un exercice, pas un accident.

Voici ce que donne une telle faute avec un Python récent : vous écrivez mesage au lieu de message, et le traceback (le rapport d'erreur que Python affiche) désigne l'endroit exact et suggère même la correction. Matthes désamorce la honte : « beaucoup d'erreurs de programmation sont des fautes de frappe d'un seul caractère sur une ligne. Si vous passez longtemps à en chercher une, sachez que vous êtes en bonne compagnie » (p. 18).

L'erreur n'est pas un échec : c'est la sortie standard du métier, et lire un traceback est une compétence qui s'enseigne, pas un don.

Traceback (most recent call last):
  File "hello_world.py", line 2,
    in <module>
    print(mesage)
          ^^^^^^
NameError: name 'mesage' is
not defined. Did you mean:
'message'?

4« Mieux vaut maintenant que jamais »

Matthes fait taper import this et commente quelques lignes du Zen de Python (une liste de maximes sur le langage) (fin du chap. 2). Celle qu'il garde pour la fin est un programme d'apprentissage à elle seule : « Mieux vaut maintenant que jamais. Vous pourriez passer le reste de votre vie à apprendre toutes les subtilités de Python et de la programmation en général, mais vous ne termineriez jamais aucun projet » (p. 31).

Tout le livre découle de cette ligne : on apprend juste assez pour construire quelque chose qui marche, et on complète en route. L'anti-perfectionnisme érigé en méthode : exactement le réflexe qui manque à ceux qui collectionnent les tutoriels sans jamais rien finir.

5Le plan s'écrit en prose, le refactoring se fait en route

Le chapitre 12 ouvre le premier projet (un jeu façon Space Invaders) par une leçon de gestion de projet déguisée. D'abord, le livre insiste pour préparer un plan avant d'écrire du code. Selon lui, ce plan n'est pas une spec de quarante pages : c'est un paragraphe en prose qui décrit le jeu.

Ensuite, le premier incrément est minuscule : une fenêtre vide, créée avec Pygame (une bibliothèque pour faire des jeux), qui s'ouvre et se ferme. Puis, à chaque tour, la même boucle : ajouter une petite fonctionnalité, vérifier à l'écran, et refactorer (nettoyer le code sans changer ce qu'il fait) AVANT d'ajouter la suivante.

Matthes le dit en toutes lettres : sur un grand projet, on refactorise souvent le code déjà écrit avant d'en ajouter. On commence donc par l'écrire le plus simplement possible, puis on le nettoie à mesure que le projet se complexifie. Le refactoring n'est pas le grand nettoyage de fin de chantier : c'est une étape de chaque tour de boucle.

6Tester est une compétence de débutant

C'est le choix le plus inattendu du livre : le chapitre 11, encore dans la moitié « bases », enseigne pytest. Pas en option, pas en annexe : entre les fichiers et le premier projet. L'argument est posé dès les premières pages : tester son code est l'une des premières compétences qui font passer de débutant à programmeur intermédiaire.

La démonstration est limpide : une fonction qui formate des noms (janis joplin en ressort en « Janis Joplin »), un test qui passe, puis on ajoute le deuxième prénom et le test casse. La règle qui suit mérite d'être gravée : quand un test échoue, ne changez pas le test, corrigez le code, parce que d'autres appels cassent exactement comme le test.

Et l'honnêteté rare : ne visez pas la couverture complète sur vos premiers projets, sauf raison précise. Tester tôt, oui. Le dogme de la couverture (tester chaque ligne), non.

from name_function import (
    get_formatted_name)

def test_first_last_name():
    name = get_formatted_name(
        'janis', 'joplin')
    assert name == 'Janis Joplin'

7La POO sert à modéliser, pas à réciter

Le chapitre sur les classes se résume à une idée : une classe est un jeu d'instructions pour fabriquer des instances (des objets construits à partir d'elle). L'exemple fil rouge est volontairement banal : une classe Dog avec un nom et un âge, puis une Car qu'on étend en ElectricCar, dont la batterie devient une classe Battery à part.

Il nomme le procédé, la composition : la voiture ne stocke pas elle-même les caractéristiques de sa batterie, elle possède un objet Battery qui s'en charge.

class Battery:
    # seul métier : la batterie
    def __init__(self, kwh=75):
        self.kwh = kwh

    def autonomie(self):
        return self.kwh * 5  # km

class ElectricCar(Car):
    def __init__(self, marque):
        super().__init__(marque)
        # la voiture POSSÈDE
        # une batterie
        self.battery = Battery()

# on délègue à l'objet
# qui s'y connaît
ma_tesla.battery.autonomie()

Le jour où la batterie se complexifie (recharge, dégradation, modèles), tout reste dans Battery, et la voiture n'en sait rien. Mais la vraie leçon arrive quand le livre fait réfléchir à ce qu'on modélise : non pas Python, mais la façon de représenter le monde réel en code.

Et là encore, le tri : @property, méthodes de classe et méthodes spéciales au-delà de __init__ relèvent de la syntaxe avancée, qui peut attendre. Modéliser d'abord.

8Trois projets, trois portes d'entrée dans le métier

La seconde moitié du livre, ce sont trois projets complets et indépendants, à faire dans l'ordre qu'on veut :

  • un jeu (Alien Invasion, avec Pygame, une bibliothèque de jeu) ;
  • de la visualisation de données (matplotlib puis Plotly, deux bibliothèques de graphiques) ;
  • une application web (un journal d'apprentissage en Django, un framework web).

Trois projets = trois métiers possibles, et le lecteur choisit sa porte. Le détail qui change tout : les données sont vraies. La météo vient de relevés de Sitka, en Alaska, et de la Vallée de la Mort. Les séismes viennent du flux temps réel de l'USGS (le service géologique américain). Le classement des dépôts les plus étoilés vient de l'API GitHub (l'interface que GitHub offre pour lire ses données). Et le projet Django va jusqu'au bout : Bootstrap (un kit de mise en forme prêt à l'emploi), comptes utilisateurs, déploiement réel sur Platform.sh. Il n'oublie pas DEBUG=False (le mode débogage coupé, comme l'exige un site public). Un livre pour débutants qui se termine avec votre application en ligne, c'est encore l'exception.

Une personne à un carrefour où trois chemins divergent : un vaisseau spatial pixelisé (le jeu), une fenêtre de navigateur (l'appli web), un graphique en barres (la visualisation de données), avec un serpent python enroulé sur le panneau indiquant les trois directions
Trois projets, trois portes : jeu, data, web. Le serpent n'a pas de préférence.

Trois choses que je ne savais pas

Mon avis, honnêtement

Ce livre fait une seule chose, et il la fait mieux que tout le monde : transformer quelqu'un qui n'a jamais codé en quelqu'un qui a terminé un vrai projet. La pédagogie est d'une propreté rare : chaque notion arrive avec l'exemple le plus simple possible, des exercices immédiats, et les pièges sont désamorcés avant d'être rencontrés. En écrivant mes propres cours, j'ai retrouvé dedans à peu près toutes les leçons que j'ai mis des années à apprendre, déjà appliquées, sans bruit.

Soyons honnêtes sur ce qu'il n'est pas. Si vous savez déjà programmer, vous allez vous ennuyer : deux chapitres entiers sur les listes, c'est le rythme d'un premier livre, pas d'une reconversion express depuis JavaScript. Et il n'explique presque jamais comment Python fonctionne sous le capot : il donne le bon geste, rarement la mécanique en dessous. C'est un choix assumé, le bon pour son public, mais il faut le savoir : on en sort capable de construire, pas de briller en entretien sur le modèle mémoire.

D'où ma règle : Python Crash Course est le premier livre, Fluent Python (déjà dans cette bibliothèque) sera le treizième. L'un vous apprend à écrire du Python qui marche, l'autre à parler le Python des natifs. Leurs notes ne se comparent pas : on ne note pas une porte d'entrée comme on note une cathédrale.

Odilon

Toujours valable en 2026 ?

Pour ce livre, la question se pose autrement : apprendre à coder a-t-il encore un sens quand l'IA écrit le code ? Réponse : la méthode de Matthes est précisément celle qu'il faut pour travailler avec une IA. Décrire ce qu'on veut en prose claire, demander le plus petit incrément qui tourne, vérifier, refactorer avant d'ajouter : c'est sa boucle de l'idée 5, et c'est mot pour mot la façon de piloter un assistant de code.

Et savoir lire un traceback, juger ce qui est trop gros ou mal découpé : c'est ce qui distingue celui qui pilote l'IA de celui qui la subit. La 3ᵉ édition (2023) est à jour : pytest, pathlib, VS Code. Seul le dernier projet vieillira : Django 4.1 et Platform.sh sont des choix datés par nature, et l'auteur maintient les correctifs sur le dépôt officiel.

Pour qui ?

Lisez-le si

  • Vous n'avez jamais programmé et vous voulez UN livre, pas une liste de 40 ressources
  • Vous vous reconvertissez et il vous faut des bases solides plus trois projets à montrer
  • Vous connaissez la syntaxe mais vous n'avez jamais terminé un projet complet
  • Vous enseignez ou créez du contenu pédagogique : c'est un cas d'école de construction de cours

Passez votre chemin si

  • Vous écrivez déjà du Python au quotidien : foncez sur Fluent Python
  • Vous venez d'un autre langage et cherchez juste la syntaxe : la doc et un bon aide-mémoire suffisent
  • Vous voulez les mécanismes internes (mémoire, typage, GIL, le verrou qui n'exécute qu'un fil à la fois) : ce n'est pas l'objet

Pour aller plus loin

La méthode de ce livre se pratique dans mes cours gratuits : les bases pas à pas dans le cours Python, la boucle plan → incrément → refactoring dans Coder avec l'IA, et le chapitre 11 se prolonge dans le cours sur les tests. Le code complet des vingt chapitres, les solutions et les cheat sheets sont sur le dépôt officiel de l'auteur. Et si vous hésitez encore sur la première marche : Par où commencer.

Commentaires (0)

Dans le même rayon

Langages côté serveur : Python, Go, PHP

Voir tout le rayon (6 fiches) →

Voir toute la bibliothèque

D'autres fiches arrivent : un livre à la fois, la substantifique moelle seulement.