Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Think Python

Think Python

Apprenez à transformer des problèmes en programmes Python clairs, puis à les tester et à les améliorer.
par Allen B. Downey 2012 296 pages
4.13
1 000+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérez la programmation comme une résolution précise de problèmes, et non comme la mémorisation de la syntaxe Python

Commencez par le problème. Downey présente la programmation comme un moyen de décomposer une tâche complexe en étapes plus petites qu’un ordinateur peut exécuter. Les programmes combinent quelques opérations de base: recevoir une entrée, produire une sortie, effectuer des calculs, choisir entre plusieurs possibilités et répéter des opérations. La difficulté ne consiste pas à mémoriser des commandes, mais à déterminer ce que la tâche exige et à exprimer clairement le plan à suivre.

Lisez le code au pied de la lettre. Contrairement au langage courant, un langage de programmation obéit à des règles strictes, tant pour son vocabulaire que pour sa structure. Un symbole mal placé peut en modifier le sens ou empêcher complètement l’exécution. Downey distingue les erreurs de syntaxe, qui empêchent le programme d’être compris, les erreurs d’exécution, qui surviennent pendant son fonctionnement, et les erreurs sémantiques, qui se produisent lorsque le programme s’exécute, mais fait autre chose que prévu. Cette distinction fournit aux débutants une première question utile: de quel type d’échec s’agit-il?

Analyse

Le geste pédagogique central du livre consiste à faire du code une forme de raisonnement explicite. Un programme ne se contente pas de décrire une intention : il s’engage dans une suite d’opérations précises. C’est ce qui rend la programmation utile au-delà du logiciel, car elle oblige à transformer des objectifs vagues en étapes vérifiables. En contrepartie, cette précision peut rendre les premières erreurs disproportionnellement pénibles. Une erreur de syntaxe peut avoir une cause infime et des conséquences bruyantes. Considérer les erreurs comme des informations sur la spécification, et non comme la preuve d’une incapacité, permet de tirer parti de cette rigueur.

Donnez à chaque fonction un rôle clair, puis généralisez les parties réutilisables

Nommez une unité utile. Une fonction regroupe une suite d’instructions sous un nom, de sorte qu’on puisse utiliser l’opération sans devoir réexaminer son implémentation. Dans l’étude de cas consacrée à la tortue, les commandes répétées pour dessiner un carré deviennent une fonction `square`. Ajouter la longueur d’un côté permet de réutiliser la fonction pour des carrés de différentes tailles; remplacer les quatre côtés fixes par un paramètre indiquant leur nombre transforme l’idée en fonction de dessin de polygones.

Concevez l’interface. L’interface d’une fonction indique aux appelants quelles entrées elle accepte, ce qu’elle fait et ce qu’elle renvoie. Son implémentation est sa méthode interne. L’exemple de la tortue distingue la forme souhaitée des détails du dessin, puis refactorise les déplacements communs pour en faire une fonction de tracé plus générale. Les préconditions décrivent ce que les appelants doivent fournir; les postconditions, ce que la fonction promet d’accomplir.

Analyse

De bonnes frontières entre fonctions servent de compression cognitive : on peut raisonner sur une opération nommée comme sur une unité, puis n’examiner ses détails internes qu’en cas de besoin. C’est aussi pourquoi le choix des noms et la conception des interfaces ne sont pas de simples questions d’apparence. Une interface claire limite ce qu’un appelant doit savoir. La généralisation a toutefois un coût : l’ajout de paramètres peut rendre une fonction plus difficile à utiliser. L’exemple de la tortue illustre le jugement essentiel à exercer : exposez les choix qui expriment l’objectif de l’utilisateur, mais gardez internes les paramètres d’implémentation que les appelants ont rarement besoin de régler.

Procédez par petites étapes vérifiables et abordez le débogage comme une enquête

Faites en sorte que chaque changement puisse être examiné. Le développement incrémental consiste à ajouter un peu de code, à l’exécuter et à vérifier si le résultat correspond à une réponse connue. Pour calculer la distance entre deux points séparés de trois unités horizontalement et de quatre verticalement, le résultat attendu est cinq. Cela fournit un test concis pour une fonction qui évolue, d’une ébauche jusqu’à un calcul. Les variables temporaires et les instructions d’affichage à des fins de diagnostic constituent du code provisoire: utiles pendant la construction, elles peuvent être supprimées du programme final.

Mettez une hypothèse à l’épreuve. Le débogage ressemble à une démarche expérimentale: observer un résultat inattendu, en proposer une cause, puis apporter une modification dont le résultat permettra de confirmer ou de réfuter l’hypothèse. Downey recommande de circonscrire la recherche en vérifiant un point intermédiaire, en réduisant les grandes entrées, en examinant les types et en expliquant le problème à voix haute. Une trace d’erreur fournit des indices, mais la ligne indiquée peut être celle où le problème s’est manifesté, et non celle où il a commencé.

Analyse

Cette approche permet concrètement de se prémunir contre l’illusion qu’un grand bloc de code peut être compris d’un seul coup. Les petits tests créent des points de contrôle, qui réduisent le nombre de causes possibles lorsqu’un problème survient. L’analogie scientifique est particulièrement juste, car le débogage repose sur des prédictions, et non sur la simple agitation. Des modifications aléatoires peuvent donner l’impression qu’un programme s’améliore tout en masquant la cause du problème. Les petites étapes ne sont toutefois pas une règle absolue : lorsqu’un programmeur maîtrise bien un composant, des changements plus importants peuvent être efficaces. L’essentiel est de préserver des moyens de vérifier le comportement.

Choisissez délibérément les répétitions et démontrez comment chaque boucle ou récursion s’achève

Répétez en prévoyant une condition d’arrêt. Une boucle exécute des instructions jusqu’à ce que sa condition change; une fonction récursive résout un problème en s’appelant elle-même pour traiter un cas plus petit. Dans l’exemple de compte à rebours de Downey, le processus s’arrête lorsque le nombre atteint zéro. Cette condition d’arrêt est le cas de base, la branche qui renvoie un résultat sans effectuer un nouvel appel récursif. Sans cas de base atteignable, la récursion se poursuit jusqu’à ce que Python signale une erreur. Une boucle peut échouer de la même manière si sa condition ne devient jamais fausse.

Améliorez une estimation avec prudence. La méthode de Newton estime une racine carrée en améliorant progressivement une valeur initiale. Le programme s’arrête lorsque deux estimations successives sont suffisamment proches, en utilisant une tolérance plutôt qu’en exigeant une égalité exacte pour des nombres à virgule flottante. Cela illustre ce qu’est un algorithme: une procédure mécanique permettant de résoudre une catégorie de problèmes. La suite de Collatz invite à la prudence: ses étapes sont simples, mais le livre précise que la terminaison pour toute valeur de départ positive n’a pas été démontrée.

Analyse

La terminaison est une forme de correction que les débutants négligent souvent. Il ne suffit pas de produire les bonnes valeurs intermédiaires si le calcul ne se termine jamais. Les deux exemples du livre montrent deux obligations distinctes : un programmeur peut souvent démontrer qu’une boucle s’achève parce qu’une variable progresse régulièrement vers sa limite, alors que certaines règles élégantes résistent aux démonstrations. Les algorithmes numériques enseignent une autre leçon : les ordinateurs représentent de nombreuses valeurs réelles de façon approximative, si bien qu’une tolérance d’arrêt pratique peut être plus pertinente qu’une égalité exacte. La bonne condition d’arrêt dépend de l’usage du résultat.

Choisissez listes modifiables, tuples immuables et chaînes de caractères selon leur usage

Sachez ce qui peut changer. Les chaînes de caractères, les listes et les tuples sont des séquences ordonnées auxquelles on accède au moyen d’indices entiers commençant à zéro. Les chaînes de caractères ne peuvent pas être modifiées sur place: toute chaîne modifiée doit être construite comme une nouvelle valeur. Les listes peuvent être modifiées, ce qui les rend pratiques pour réunir et mettre à jour des éléments. Les tuples sont également des séquences, mais leurs éléments ne peuvent pas être réaffectés; ils conviennent donc aux regroupements fixes de valeurs.

Méfiez-vous des références partagées. Si deux variables désignent la même liste, toute modification de cette liste au moyen de l’un des noms est également visible par l’autre. C’est ce qu’on appelle l’aliasing. Une tranche peut créer une liste distincte, tandis qu’une copie superficielle d’un objet peut encore partager les objets qu’il contient; une copie profonde duplique aussi ces objets imbriqués. Ces distinctions comptent dans les fonctions qui reçoivent des listes, car une fonction peut modifier les données de l’appelant sans renvoyer une nouvelle liste.

Analyse

La distinction entre valeur et identité fait de la manipulation des séquences une leçon de gestion de l’état. L’immuabilité peut réduire les interférences accidentelles, puisqu’une chaîne ou un tuple partagé ne peut pas être modifié à l’insu d’une autre partie du programme. La mutabilité n’est toutefois pas un défaut. Les listes sont précieuses précisément parce qu’elles peuvent changer. La question de conception est de savoir si ces changements doivent être visibles par d’autres références. Décider explicitement si une fonction modifie une entrée ou renvoie un remplacement est une petite habitude qui a de grandes conséquences sur la lisibilité.

Utilisez les dictionnaires pour rechercher rapidement, compter et représenter les relations entre les données

Représentez ce qui compte. Un dictionnaire associe des clés à des valeurs; il permet donc naturellement de stocker des relations, par exemple entre un mot et sa traduction, ou entre un caractère et sa fréquence. Un histogramme compte les occurrences en utilisant chaque élément observé comme clé. Contrairement à la recherche dans une liste, qui s’effectue du début à la fin, l’appartenance à un dictionnaire et la recherche d’une valeur y prennent généralement un temps presque constant, quel que soit le nombre d’entrées.

Laissez la tâche déterminer la structure. Dans l’étude de cas sur le texte de Markov, le programme enregistre quels mots peuvent suivre une séquence donnée, puis utilise ces relations pour générer un nouveau texte. Les préfixes doivent servir de clés de dictionnaire; les tuples immuables conviennent donc mieux que les listes modifiables. La structure de données appropriée dépend des opérations nécessaires: ajouter des entrées, vérifier l’appartenance à un ensemble ou choisir un résultat aléatoire pondéré. Dans Emma de Jane Austen, le programme présenté compte 161 080 mots et 7 214 mots distincts.

Analyse

Une structure de données n’est pas qu’un contenant : elle rend certaines opérations naturelles et d’autres peu commodes. Un dictionnaire transforme le comptage en association directe, tandis qu’une séquence préserve l’ordre et permet de parcourir les éléments. L’exemple de Markov rend ce choix de conception visible : la structure utilisée pour l’analyse doit permettre à la fois de stocker le contexte et de retrouver les continuations possibles. Une réserve s’impose toutefois concernant les affirmations de rapidité, qui dépendent des circonstances. La recherche dans un dictionnaire est généralement efficace, mais la taille des données, l’espace mémoire et la charge de travail réelle comptent aussi. Le conseil pratique du livre est judicieux : choisissez en fonction des opérations nécessaires, puis mesurez les performances si elles deviennent problématiques.

Gardez stable l’interface d’un objet tout en améliorant sa conception interne

Regroupez les états liés. Une classe définit un type créé par le programmeur, et une instance réunit les données et les opérations qui lui sont associées. Un objet `Time` peut contenir des heures, des minutes et des secondes; ses méthodes peuvent l’afficher, le comparer ou lui ajouter une durée. La forme orientée objet rend explicite le lien entre les données et les opérations. On retrouve la même idée dans l’exemple des cartes à jouer, où les cartes, les paquets et les mains sont représentés par des classes apparentées.

Distinguez les garanties du mécanisme. Les appelants devraient dépendre des méthodes proposées par un objet, et non de la façon dont ses attributs sont stockés. Une durée peut être représentée par des champs distincts ou par un nombre de secondes, tout en conservant la même interface utile. Les fonctions pures renvoient des résultats sans modifier leurs entrées; les fonctions modificatrices changent les objets qu’elles reçoivent. L’héritage permet de réutiliser du comportement, mais complique aussi la recherche des méthodes: une classe enfant devrait donc rester utilisable partout où l’on s’attend à trouver sa classe parente.

Analyse

La conception orientée objet est particulièrement utile lorsqu’elle réduit le nombre d’éléments qui doivent changer ensemble. Une interface stable permet à une implémentation d’évoluer sans obliger à réécrire tous ses appelants. Cette idée rejoint le principe général de modularité en ingénierie : un composant peut être remplacé si ses engagements envers l’extérieur restent inchangés. L’héritage favorise la réutilisation, mais ne garantit pas à lui seul une bonne structure. Si une sous-classe modifie les attentes sur lesquelles comptent les appelants, la réutilisation apparente dissimule une dépendance. L’importance que le livre accorde à la clarté des interfaces aide à distinguer l’abstraction utile de la création de classes pour elle-même.

Stockez l’état du programme dans des fichiers et séparez le code réutilisable de son exécution

Faites persister les résultats. Un programme éphémère perd ses données de travail lorsqu’il se termine. L’écriture dans un fichier conserve les informations au-delà d’une seule exécution, tandis qu’une base de données peut organiser les données persistantes sous forme de paires clé-valeur. Les opérations sur les fichiers en Python permettent de lire et d’écrire du texte; ouvrir un fichier en mode écriture peut effacer son contenu précédent, il est donc important de choisir le bon mode. Lorsqu’une opération sur un fichier échoue, la gestion des exceptions permet au programme de signaler le problème ou de se terminer plus proprement.

Faites en sorte que les modules soient réutilisables. N’importe quel fichier Python peut fournir des fonctions à un autre programme sous forme de module. Mais l’importation d’un fichier devrait généralement définir des outils, et non lancer inopinément le code de démonstration qu’il contient. Le test ` name ` permet de distinguer un fichier exécuté comme script d’un fichier importé ailleurs. Cette structure facilite les tests et la réutilisation. Le livre présente aussi la sérialisation avec pickle, qui convertit de nombreux objets Python en une forme pouvant être stockée puis reconstruite, ainsi que les tubes, qui permettent à Python d’exécuter des commandes externes.

Analyse

La persistance transforme un programme, qui ne faisait qu’un calcul ponctuel, en participant d’un processus continu. Elle soulève des questions pratiques absentes des exercices courts : des fichiers peuvent manquer, des permissions peuvent empêcher d’y accéder et des écritures peuvent écraser des données existantes. La gestion des exceptions n’est donc pas décorative : elle reconnaît l’environnement dans lequel les logiciels fonctionnent. De même, séparer les définitions d’un module du comportement d’un script facilite la composition du code. Un module utile se comporte comme un outil rangé sur une étagère, disponible lorsqu’on le demande, plutôt que comme un outil qui se met à fonctionner dès qu’on ouvre l’armoire.

Comparez les algorithmes selon l’évolution de leur coût lorsque la taille des entrées augmente

Mesurez la croissance, pas une seule exécution. L’analyse des algorithmes décrit l’évolution du temps d’exécution ou de l’espace mémoire nécessaire en fonction de la taille des entrées. Une recherche linéaire peut examiner chaque élément; doubler la taille de la collection peut donc presque doubler le travail. Une recherche par dichotomie divise à plusieurs reprises une collection triée en deux; le livre estime qu’il faut environ 17 étapes pour parcourir une liste de 113 809 mots. Le temps exact dépend du matériel et de l’implémentation, mais les taux de croissance révèlent quelle méthode passe mieux à l’échelle.

Comprenez les compromis. La notation grand O regroupe les algorithmes selon leur taux de croissance dominant, par exemple linéaire, logarithmique ou quadratique. Les dictionnaires Python utilisent des tables de hachage pour que les recherches courantes prennent généralement un temps constant. Leur implémentation redimensionne la table et redistribue les entrées à mesure qu’elle se remplit; certaines insertions coûtent donc davantage, même si le coût moyen d’insertion reste constant sur un grand nombre d’opérations. Pour les tâches ordinaires, utilisez d’abord les outils éprouvés du langage, puis profilez le programme avant de les remplacer par un algorithme plus élaboré.

Analyse

L’analyse asymptotique permet de raisonner au-delà des limites d’un test de performance. Une mesure décrit une machine, une entrée et un moment particuliers ; une classe de croissance décrit un schéma susceptible de se maintenir à mesure que la tâche prend de l’ampleur. Le livre évite aussi de traiter la théorie comme un substitut au jugement. Une méthode plus simple peut être préférable pour de petites entrées, et les constantes peuvent compter en pratique. La démarche la plus solide comporte donc plusieurs étapes : comprendre la croissance probable, utiliser une implémentation fiable et profiler le programme réel avant de l’optimiser. La complexité donne une orientation, sans garantir le résultat de chaque exécution.

Analyse

Think Python est un cours de programmation pour débutants organisé selon une progression délibérée: les valeurs et les instructions mènent aux fonctions, au contrôle du flux, aux collections, aux données persistantes, aux objets et à l’analyse des algorithmes. Sa thèse distinctive est qu’apprendre Python, c’est aussi apprendre une méthode pour transformer des problèmes en calculs précis et vérifiables. L’ordre des notions compte. Chaque nouvelle abstraction est introduite après que les lecteurs ont découvert le problème qu’elle résout, ce qui réduit l’effet de trappe que Downey décrit dans des ouvrages de programmation antérieurs.

Le fil conducteur le plus fort du livre n’est pas une syntaxe particulière, mais la pratique répétée qui consiste à rendre visible une structure cachée. Les diagrammes d’état clarifient les références et les modifications. Les diagrammes de pile expliquent les appels de fonctions et la récursion. Les interfaces distinguent la promesse d’une fonction de son implémentation. Les sorties de test et les invariants mettent au jour des hypothèses qui resteraient autrement implicites. Ces outils apprennent aux lecteurs à construire un modèle mental, à le comparer au comportement réel, puis à réviser le code ou le modèle lorsqu’ils ne concordent pas.

Les exemples contribuent eux aussi à faire de la programmation autre chose qu’un défilé de fonctionnalités du langage. Les dessins de tortues motivent la généralisation et la refactorisation; les jeux de lettres transforment la recherche en une méthode réutilisable; le comptage des mots chez Jane Austen motive les histogrammes et le choix des structures de données; la génération de textes de Markov montre comment la représentation façonne le résultat. Les exemples sont modestes, mais cette échelle réduite est utile sur le plan pédagogique: les apprenants peuvent examiner tout le mécanisme au lieu de devoir faire confiance à une boîte noire.

La principale limite tient à l’étendue du programme. La progression introduit de nombreux concepts, de la récursion et de la programmation orientée objet aux fichiers et à l’analyse en notation grand O, mais leur maîtrise exige beaucoup de pratique au-delà de la lecture. Certains exemples simplifient également des décisions qui se révèlent plus exigeantes dans les logiciels de production, notamment en matière de gestion des erreurs, d’interfaces et de performances. C’est tout à fait approprié pour une introduction, à condition de considérer le livre comme un fondement et non comme un exposé complet du génie logiciel.

La leçon la plus durable est un cycle pratique: formuler la tâche, choisir une représentation, construire une petite version fonctionnelle, la tester, puis améliorer sa structure uniquement lorsque les observations le justifient. Python est le moyen. La pensée computationnelle claire est le sujet.

Résumé en 30 secondes
La programmation commence par la traduction d’une tâche en opérations précises, puis par l’organisation de ces opérations en fonctions aux entrées et aux résultats clairement définis. Construisez votre programme de façon incrémentale et utilisez de petits tests pour localiser les erreurs. Choisissez entre listes, tuples et dictionnaires selon la manière dont les données doivent être modifiées ou retrouvées. Les fichiers conservent les informations d’une exécution à l’autre, tandis que des interfaces stables rendent le code réutilisable. Comparez les algorithmes selon la croissance de leurs coûts : la recherche par dichotomie parcourt une liste de 113 809 mots en environ 17 étapes.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.13 sur 5
Moyenne de 1 000+ évaluations de Goodreads et Amazon.

Think Python reçoit principalement des critiques positives, qui saluent sa clarté, sa concision et son approche adaptée aux débutants. Les lecteurs apprécient les exercices pratiques, l’accès gratuit et l’accent mis sur les concepts de l’informatique. Certains le trouvent difficile pour les débutants absolus, et relèvent des exemples et des exercices très axés sur les mathématiques. Le livre est loué pour sa structure et pour sa couverture des bases de Python et des fondamentaux de la programmation. Si quelques lecteurs l’ont trouvé frustrant ou trop technique, nombreux sont ceux qui le recommandent comme une excellente introduction à Python et à la programmation, aussi bien aux novices qu’aux personnes ayant déjà de l’expérience.

Votre note :
4.53
285 évaluations
Envie de lire le livre complet ?

Glossaire

développement incrémental

Petites modifications, tests fréquents

Une manière de construire un programme en ajoutant et en testant une petite quantité de code à la fois. Les valeurs intermédiaires peuvent être stockées et inspectées, et du code de diagnostic temporaire peut révéler où un calcul déraille. Une fois le programme fonctionnel, ce code provisoire peut être supprimé ou simplifié.

code provisoire

Code temporaire de développement

Code utilisé pour faciliter la construction ou le débogage d’un programme, mais qui n’est pas nécessaire dans sa forme finale. Il peut s’agir, par exemple, d’instructions d’affichage à des fins de diagnostic ou de variables temporaires qui font apparaître des résultats intermédiaires. Le code provisoire aide à tester un programme en cours de développement et est généralement supprimé ou regroupé une fois son comportement vérifié.

garde

Protège contre les cas non valides

Un schéma conditionnel qui vérifie la présence d’entrées ou de circonstances susceptibles de faire échouer un calcul ultérieur. Le programme traite ces cas avant d’atteindre le calcul principal. Dans une fonction récursive, par exemple, des vérifications peuvent rejeter un type non pris en charge ou une valeur négative avant le début de la récursion.

aliasing

Plusieurs noms, un seul objet

Situation dans laquelle deux variables ou plus font référence au même objet. Si cet objet est modifiable, le changer par l’intermédiaire d’une variable modifie ce que les autres variables observent. L’aliasing est utile lorsque les modifications partagées sont voulues, mais peut produire des comportements surprenants lorsqu’une fonction modifie une liste qui lui a été fournie par son appelant.

mémo

Résultat enregistré pour être réutilisé

Valeur calculée précédemment et stockée afin qu’un programme puisse la réutiliser au lieu de refaire le même travail. Dans l’exemple de Fibonacci du livre, un dictionnaire mémorise les résultats connus. Lorsque la fonction est appelée avec une valeur déjà stockée, elle renvoie directement le résultat correspondant, évitant ainsi de répéter des calculs récursifs.

analyse de Markov

Modélise les mots susceptibles de suivre

Méthode permettant de représenter les éléments susceptibles de suivre une séquence donnée dans un texte. Le programme associe chaque préfixe — par exemple, une courte séquence de mots — aux mots qui peuvent le suivre. Il peut ensuite générer du texte en choisissant à plusieurs reprises une continuation et en mettant à jour le préfixe. Le choix des structures de données a des conséquences sur l’implémentation comme sur les performances.

polymorphe

Fonctionne avec plusieurs types

Une fonction est polymorphe lorsqu’elle fonctionne avec des valeurs de types différents, à condition que celles-ci prennent en charge les opérations qu’elle utilise. Une fonction qui construit un histogramme en comptant les éléments peut traiter des chaînes, des listes ou des tuples si leurs éléments peuvent servir de clés de dictionnaire. Le code peut ainsi être réutilisé sans branchements explicites selon le type.

notation grand O

Décrit le taux de croissance

Notation qui regroupe les algorithmes selon l’évolution de leurs besoins en ressources à mesure que la taille des entrées augmente. Elle met l’accent sur le terme dominant et ignore les facteurs constants ainsi que les termes d’ordre inférieur. Par exemple, O(n) décrit une croissance linéaire, tandis que O(n au carré) décrit une croissance quadratique. Elle guide les comparaisons, mais ne prédit pas tous les temps d’exécution en pratique.

table de hachage

Stockage rapide de clés et de valeurs

Structure de données qui utilise une fonction de hachage pour associer des clés à des emplacements de stockage, ce qui permet généralement de retrouver une clé en temps constant. Les dictionnaires Python utilisent cette approche. À mesure que les entrées s’accumulent, la structure peut être redimensionnée et les clés redistribuées : certaines insertions ponctuelles deviennent alors plus coûteuses, tandis que le coût moyen des insertions reste constant sur un grand nombre d’opérations.

FAQ

1. De quoi parle Think Python d’Allen B. Downey ?

  • Une introduction complète à Python : Le livre propose une introduction approfondie à la programmation en Python 3. Il part des notions de base et aborde progressivement des sujets avancés.
  • L’accent sur la résolution de problèmes : Il apprend aux lecteurs à penser comme des informaticiens, en présentant la programmation comme un outil pour formuler et résoudre des problèmes de manière créative.
  • La couverture des concepts fondamentaux : Les principaux concepts de programmation — variables, fonctions, conditions, récursion, structures de données, programmation orientée objet et analyse d’algorithmes — sont présentés de façon systématique.
  • Une approche pratique de l’apprentissage : Le livre s’appuie sur des exercices, des études de cas et des exemples concrets pour consolider les acquis et encourager la pratique.

2. Pourquoi lire Think Python d’Allen B. Downey ?

  • Un ouvrage accessible aux débutants : Destiné aux personnes qui découvrent la programmation, le livre offre des explications claires et limite le jargon afin de faciliter l’apprentissage.
  • Un équilibre entre théorie et pratique : Il associe des exercices de programmation concrets à des fondements théoriques, préparant les lecteurs aux défis de la programmation dans le monde universitaire comme dans le monde professionnel.
  • L’accent sur les bonnes habitudes : Downey insiste sur les stratégies de débogage, la lisibilité du code et la conception facile à maintenir, afin d’aider les lecteurs à acquérir de bonnes habitudes de programmation dès le départ.
  • Une édition mise à jour pour Python 3 : La deuxième édition est entièrement adaptée à Python 3. Elle comprend de nouveaux chapitres et des conseils pour exécuter Python dans un navigateur.

3. Quels sont les principaux enseignements de Think Python d’Allen B. Downey ?

  • La résolution de problèmes est au cœur du sujet : La compétence la plus importante consiste à apprendre à résoudre des problèmes par le calcul, et non à simplement mémoriser la syntaxe.
  • La programmation est un processus : Écrire, tester et déboguer du code sont des démarches itératives qui exigent de la patience et une pensée méthodique.
  • L’importance de la conception : Le livre met constamment l’accent sur une bonne conception logicielle, notamment la modularité, la lisibilité et la facilité de maintenance.
  • Apprendre en pratiquant : Le livre encourage l’apprentissage actif au moyen d’exercices, d’études de cas et de projets pratiques.

4. Quelles sont les citations les plus marquantes de Think Python d’Allen B. Downey et que signifient-elles ?

  • Sur la résolution de problèmes : « La compétence la plus importante pour un informaticien est la résolution de problèmes. » Cette phrase souligne l’importance que le livre accorde au développement de la pensée critique et créative.
  • Sur le débogage : « Une fois éliminé l’impossible, ce qui reste, aussi improbable que cela puisse paraître, doit être la vérité. » (Sherlock Holmes) Cette citation encourage le raisonnement logique et la persévérance dans le débogage.
  • Sur les tests : « Les tests d’un programme peuvent servir à montrer la présence de bogues, mais jamais leur absence ! » (Edsger W. Dijkstra) Ce rappel souligne que les tests sont indispensables, mais qu’ils ne peuvent garantir un code sans bogues.

5. Quels concepts fondamentaux de programmation Think Python d’Allen B. Downey aborde-t-il ?

  • Variables et expressions : Le livre commence par les variables, les expressions et les instructions, posant ainsi les bases de la programmation.
  • Fonctions et contrôle du flux : Il présente très tôt les fonctions, les paramètres, les valeurs de retour, les conditions et les boucles afin d’établir les compétences fondamentales en programmation.
  • Récursion et itération : La récursion et l’itération sont expliquées comme des outils essentiels pour répéter des opérations et décomposer des problèmes.
  • Débogage et types d’erreurs : Les lecteurs apprennent à reconnaître et à corriger les erreurs de syntaxe, d’exécution et de sémantique, ainsi qu’à appliquer des conseils pratiques de débogage.

6. Comment Think Python d’Allen B. Downey explique-t-il et enseigne-t-il les fonctions ?

  • Définir et utiliser des fonctions : Le livre explique comment définir, appeler et composer des fonctions, notamment en utilisant des paramètres et des valeurs de retour.
  • Fonctions avec ou sans valeur de retour : Il distingue les fonctions qui renvoient des valeurs (dites « fructueuses ») de celles qui réalisent des actions sans renvoyer de valeur (dites « vides »).
  • Les avantages des fonctions : Les fonctions améliorent la lisibilité du code, réduisent les répétitions et facilitent le débogage modulaire ainsi que la réutilisation du code.
  • Exercices pratiques : Les lecteurs s’exercent à écrire et à utiliser des fonctions grâce à des exercices ciblés et à des exemples concrets.

7. Quelles structures de données Think Python d’Allen B. Downey met-il en avant et comment les explique-t-il ?

  • Chaînes et listes : Le livre présente les chaînes comme des séquences de caractères et les listes comme des séquences modifiables, et enseigne l’indexation, le découpage et le parcours des éléments.
  • Dictionnaires et tuples : Les dictionnaires sont présentés comme des associations de clés et de valeurs, tandis que les tuples sont décrits comme des séquences immuables destinées à regrouper des éléments fixes.
  • Structures composées et imbriquées : Le livre explore les listes de tuples, les dictionnaires dont les clés sont des tuples et les structures de données imbriquées, en soulignant leur souplesse et les pièges courants.
  • Outils de débogage : Des modules comme structshape sont présentés pour aider à déboguer et à examiner des structures de données complexes.

8. Comment Think Python d’Allen B. Downey enseigne-t-il la récursion et l’itération ?

  • Principes fondamentaux de la récursion : Le livre explique la récursion à l’aide de cas de base et d’appels récursifs, en s’appuyant sur des exemples comme les fonctions de calcul de la factorielle et de Fibonacci.
  • L’itération comme solution de rechange : Il présente les boucles while et for et montre comment réécrire certaines fonctions récursives sous forme itérative pour gagner en efficacité.
  • Déboguer la récursion : Downey recommande de suivre les appels récursifs à l’aide d’instructions d’affichage et de comprendre le déroulement de l’exécution pour déboguer la récursion.
  • Comparer les méthodes : Les lecteurs apprennent à choisir entre récursion et itération en tenant compte de l’efficacité et de la clarté.

9. Comment Think Python d’Allen B. Downey enseigne-t-il les concepts de la programmation orientée objet ?

  • Une introduction progressive : Le livre commence par la définition de classes, la création d’objets et l’utilisation d’attributs et de méthodes pour modéliser des entités du monde réel.
  • Héritage et polymorphisme : Il aborde les sous-classes, la redéfinition de méthodes et le polymorphisme, et montre comment étendre et personnaliser un comportement.
  • Méthodes spéciales et surcharge d’opérateurs : Les lecteurs découvrent __init__, __str__ et la surcharge d’opérateurs afin de rendre les classes plus idiomatiques en Python.
  • Principes de conception : Des notions comme l’encapsulation, la conception d’interfaces et le principe de substitution de Liskov sont présentées pour favoriser la maintenabilité du code.

10. Quels conseils et stratégies de débogage Allen B. Downey propose-t-il dans Think Python ?

  • Les types d’erreurs : Le livre classe les erreurs en erreurs de syntaxe, d’exécution et de sémantique, et explique comment reconnaître et corriger chacune d’elles.
  • Une démarche de débogage en cinq étapes : Downey conseille de lire attentivement le code, de mener des expériences, de réfléchir aux causes possibles, d’expliquer le problème à un interlocuteur imaginaire et de simplifier le code.
  • Assertions et vérifications de cohérence : L’utilisation d’instructions assert et de contrôles autonomes est encouragée afin de repérer rapidement les erreurs.
  • Gestion des émotions : Le livre reconnaît les frustrations liées au débogage et propose des conseils pour gérer ses émotions de façon constructive.

11. Quels concepts algorithmiques et quelles méthodes d’analyse Think Python d’Allen B. Downey aborde-t-il ?

  • Ordre de croissance : Le livre présente la notation grand O et explique la croissance constante, linéaire, quadratique et logarithmique ainsi que leurs effets sur les performances.
  • Algorithmes de recherche et de tri : Il traite de la recherche linéaire et de la recherche par dichotomie, du tri à bulles et du tri par base, en discutant de leurs usages et de leur efficacité.
  • Performances des structures de données : Le livre explique l’efficacité des recherches dans les dictionnaires par rapport à celles dans les listes, ainsi que les fonctions de hachage et les stratégies de redimensionnement.
  • Pensée algorithmique : Les lecteurs sont encouragés à analyser et à comparer les algorithmes adaptés à différents problèmes.

12. Quelles fonctionnalités Python avancées et quels « petits plus » Think Python d’Allen B. Downey présente-t-il ?

  • Expressions conditionnelles : Le livre montre comment écrire des instructions if-else concises en ligne pour les affectations et les valeurs de retour.
  • Compréhensions de listes et de générateurs : Il explique comment utiliser les compréhensions de listes pour appliquer une transformation et filtrer des éléments, ainsi que les expressions génératrices pour parcourir des données en économisant la mémoire.
  • Outils du module collections : Des fonctionnalités comme set, Counter, defaultdict et namedtuple sont présentées pour produire un code plus clair et plus efficace.
  • Gestion des fichiers et persistance : Le livre aborde la lecture et l’écriture de fichiers, l’utilisation du module os et la sérialisation d’objets à l’aide de pickle et shelve pour assurer un stockage persistant.

À propos de l'auteur

Allen B. Downey est professeur émérite à Olin College et auteur prolifique de manuels gratuits sur les logiciels et la science des données. Parmi ses ouvrages figurent Think Python, Think Bayes et Think Complexity, tous publiés par O'Reilly Media. Le parcours universitaire de Downey est remarquable : il est titulaire d’un doctorat en informatique de l’Université de Californie à Berkeley, ainsi que d’une maîtrise et d’une licence du MIT. Il tient un blog intitulé « Probably Overthinking It », dans lequel il explore des sujets liés aux probabilités bayésiennes et aux statistiques, témoignant ainsi de son expertise dans ces domaines.

Autres livres de Allen B. Downey

Télécharger le PDF

Pour garder le résumé de Think Python pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Think Python sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
600,000+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...