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
Programmer en Python

Programmer en Python

Titre original: Fluent Python
Faites travailler davantage les fonctionnalités intégrées de Python, avec moins de code et moins d’abstractions fragiles.
par Luciano Ramalho 2015 850 pages
4.62
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

Faites parler vos objets avec les protocoles de Python, et le langage fera le reste

Respectez les contrats du langage. Le modèle de données de Python est l’ensemble des méthodes spéciales qui permettent aux objets définis par l’utilisateur de fonctionner avec la syntaxe intégrée. Un FrenchDeck qui implémente uniquement ` len ` et ` getitem ` prend déjà en charge `len`, l’indexation, le découpage en tranches, l’itération, les tests d’appartenance et des outils comme `random.choice` et `sorted`. L’interpréteur appelle ces méthodes à votre place, souvent à l’occasion d’une opération familière plutôt que d’un appel direct à une méthode.

Appuyez-vous sur les comportements existants. La même idée s’applique aux opérateurs, au formatage, aux blocs `with` et aux opérations asynchrones. Par exemple, ` enter ` et ` exit ` permettent à un objet de gérer la préparation et le nettoyage autour d’un bloc `with`. De petites interfaces standard permettent aux types personnalisés d’utiliser les bibliothèques de Python au lieu de reconstruire leurs fonctionnalités de zéro.

Analyse

Ce qui est puissant ici, c’est que la souplesse de Python n’est pas simplement une autorisation de personnaliser la syntaxe. Elle permet à des composants écrits indépendamment de coopérer en s’appuyant sur des attentes comportementales partagées. Cela rappelle un contrat d’API bien conçu : les appelants s’intéressent à ce qu’un objet sait faire, pas à ses ancêtres. Le risque, c’est qu’une syntaxe familière puisse masquer des sémantiques surprenantes. Une implémentation personnalisée de + ou de len() devrait donc respecter les attentes que les utilisateurs associent déjà à ces opérations.

Choisissez la collection dont le modèle mémoire correspond au travail

Adaptez la structure à l’usage. Les listes et les tuples contiennent des références à des objets Python distincts; ils peuvent donc accueillir des données hétérogènes ou imbriquées. Les tableaux stockent directement des valeurs machine de façon compacte et conviennent aux grandes séquences numériques. Le livre compare dix millions de nombres flottants en double précision: le fichier binaire du tableau occupe 80 millions d’octets, tandis qu’un fichier texte contenant les mêmes valeurs en occupe environ 181,5 millions. NumPy ajoute les tableaux multidimensionnels et des opérations rapides appliquées à des jeux de données entiers.

Choisissez aussi le comportement adapté. Les tuples conviennent aux enregistrements à champs fixes ou aux séquences immuables, mais un tuple contenant une liste n’est pas profondément immuable. Pour ajouter et retirer fréquemment des éléments aux deux extrémités, une `deque` est préférable à une liste. Les ensembles sont utiles lorsque les tests d’appartenance et l’unicité comptent davantage que l’ordre.

Analyse

Choisir une structure de données relève de la conception des systèmes, pas d’une simple question de style. La disposition en mémoire influe sur l’utilisation du cache, les copies et le coût des opérations, tandis que l’interface publique indique ce que représentent les données. La distinction du livre entre conteneurs flexibles et séquences plates compactes offre un premier repère utile. Attention toutefois : la compacité ne suffit pas à rendre un tableau préférable. La structure la plus simple qui exprime le domaine et la charge de travail est généralement le choix le plus sûr.

Considérez chaque affectation comme le partage d’une référence, pas comme une copie des données

Les noms désignent des objets. En Python, `b = a` associe un second nom à la même liste; cela n’en crée pas une copie. Si l’un ou l’autre nom modifie cette liste, les deux noms constatent le changement. L’égalité compare les valeurs, tandis que `is` vérifie si deux noms désignent le même objet. Les tuples ne règlent pas le problème: leurs références ne peuvent pas être remplacées, mais un objet mutable qu’ils contiennent peut tout de même changer.

Protégez vos frontières. Une copie superficielle ne duplique que le conteneur externe. L’exemple du bus présenté dans le livre montre comment le partage d’une liste de passagers permet à la suppression d’une personne du bus de modifier silencieusement la liste de l’équipe de l’appelant. Un argument par défaut mutable provoque un problème similaire: des bus supposément distincts partagent la même liste par défaut. Utilisez `None` et créez une nouvelle liste, ou copiez une entrée si la fonction doit être propriétaire de ses données.

Analyse

C’est en miniature le modèle pratique de propriété de Python. Il offre aux programmeurs efficacité et souplesse, mais laisse au concepteur de l’API la responsabilité de gérer les alias. Les langages qui imposent des règles explicites de propriété rendent certaines décisions de partage visibles à la compilation ; Python s’en remet plutôt aux conventions, à la documentation et aux copies préventives. Tout copier n’est pas une solution, car cela consomme de la mémoire et peut briser un partage voulu. La question essentielle est de savoir si les appelants s’attendent à ce que les modifications se propagent au-delà de la frontière.

Utilisez des fonctions comme stratégies interchangeables avant de créer des classes à méthode unique

Les fonctions sont des éléments à part entière. En Python, les fonctions peuvent être stockées, transmises comme arguments et renvoyées par d’autres fonctions. Dans l’exemple des remises du livre, les commandes bénéficient de l’une de trois fonctions: une remise de fidélité de 5 %, une remise de 10 % sur les articles achetés en quantité suffisante, ou une remise de 7 % pour les commandes contenant au moins dix articles distincts. Remplacer les classes de stratégie à méthode unique par des fonctions élimine le code superflu tout en gardant chaque règle distincte.

N’ajoutez des mécanismes que s’ils sont utiles. Un décorateur d’enregistrement peut collecter les nouvelles stratégies, évitant ainsi de devoir mettre à jour manuellement une liste centrale. Les fermetures permettent à une fonction de conserver un état, comme dans le calcul d’une moyenne glissante, tandis que les décorateurs peuvent envelopper les appels pour mesurer leur durée ou mettre les résultats en cache. Lorsque le comportement appelable nécessite un état interne important, une classe dotée de ` call ` peut rester le choix le plus clair.

Analyse

La distinction utile n’est pas entre programmation fonctionnelle et programmation orientée objet, mais entre la structure nécessaire au problème et celle qui ne l’est pas. Les fonctions de première classe facilitent la composition et le test de petites politiques, tandis que les objets appelables restent disponibles lorsque l’état et plusieurs opérations vont de pair. C’est une façon concrète de réduire la complexité accidentelle. Remplacer toutes les classes par des fonctions peut toutefois brouiller l’identité ou le cycle de vie d’un domaine ; le gain vient du choix d’une abstraction plus légère lorsqu’elle convient réellement.

Ajoutez des annotations de type là où elles détectent de vraies erreurs, pas pour remplir un quota

Les annotations guident les outils, pas Python lui-même. Le système de types progressif de Python permet d’ajouter des annotations à un projet par étapes. Un vérificateur comme Mypy peut signaler qu’une fonction déclarée comme acceptant un `Duck` est appelée avec un simple `Bird`, même si, à l’exécution, Python continue de s’appuyer sur les opérations prises en charge. Les annotations de type ne valident pas les valeurs à l’exécution, ne garantissent pas les règles métier et n’accélèrent pas l’exécution.

Décrivez le comportement, pas seulement les noms. Un protocole statique peut préciser qu’un argument doit prendre en charge une opération donnée, préservant ainsi la souplesse du typage canard tout en permettant des vérifications statiques. `TypedDict` peut décrire un enregistrement de type JSON, mais ne peut pas prouver que les données analysées depuis du JSON possèdent réellement les clés ou les valeurs promises. La validation à l’exécution et les tests restent nécessaires, et certaines API dynamiques de Python ne valent pas la peine d’être alourdies dans le seul but d’éliminer le code sans annotation.

Analyse

Le typage est particulièrement utile lorsqu’il rend visibles les hypothèses d’une équipe et détecte les incompatibilités avant l’exécution. Il l’est beaucoup moins quand les annotations ne font que répéter l’évidence ou donnent à tort l’impression que des données externes ont été vérifiées. La distinction du livre entre analyse statique et comportement à l’exécution est essentielle à une époque où les systèmes de types façonnent de plus en plus la conception des API. Une politique raisonnable considère les annotations comme une source supplémentaire de retours, non comme un substitut aux tests, à la validation ou au jugement.

Privilégiez la composition; faites mériter à l’héritage son coût en couplage

La réutilisation peut créer un couplage trop fort. Hériter des classes intégrées `dict` ou `list` peut entraîner des surprises, car certaines méthodes implémentées en C n’appellent pas les redéfinitions ajoutées par une sous-classe. Le dictionnaire personnalisé du livre fonctionne plus fiablement lorsqu’il repose sur `collections.UserDict`, qui délègue les opérations à un dictionnaire interne. La composition évite souvent ces pièges: un objet peut utiliser les services d’un autre sans prétendre être cet autre objet.

Utilisez l’héritage à bon escient. L’héritage multiple repose sur l’ordre de résolution des méthodes et sur des appels coopératifs à `super()`. Les mixins peuvent ajouter un comportement ciblé, mais toutes les méthodes de la chaîne doivent coopérer. L’auteur recommande des interfaces abstraites explicites pour les relations entre types, des mixins restreints pour la réutilisation du code et des classes agrégées lorsqu’une combinaison utile est destinée aux utilisateurs.

Analyse

L’héritage peut exprimer une véritable relation de sous-typage, mais il lie aussi les choix d’implémentation à travers une hiérarchie de classes. La composition rend cette dépendance explicite au point d’utilisation et se modifie souvent plus facilement. Les exemples de Django et Tkinter montrent que l’héritage multiple peut fonctionner, mais aussi qu’un utilisateur risque d’hériter d’un vaste ensemble de fonctionnalités dont il n’a pas besoin. Il ne s’agit pas d’interdire l’héritage, mais de distinguer la substituabilité de la réutilisation par commodité.

Utilisez des générateurs paresseux pour traiter des flux sans construire le résultat entier

Produisez les données à la demande. Un itérateur fournit un élément à la fois. Une fonction génératrice utilise `yield` pour conserver son état entre les éléments, évitant ainsi la gestion manuelle des indices d’un itérateur classique écrit sous forme de classe. Dans l’exemple `Sentence` du livre, on commence par stocker d’emblée tous les mots, puis on passe à `re.finditer` afin de ne trouver chaque mot qu’au moment où il est demandé.

Composez le flux. Les expressions génératrices peuvent alimenter des constructeurs ou des boucles sans créer de liste intermédiaire. Les fonctions `itertools` de la bibliothèque standard filtrent, combinent et transforment les itérables; `yield from` (délégation à un sous-générateur) permet à un générateur de déléguer à un autre, comme dans un parcours d’arbre. Le traitement paresseux peut économiser beaucoup de mémoire, mais ne rend pas sans risque la matérialisation d’une entrée infinie: appeler `list()` sur un générateur infini ne terminera jamais.

Analyse

Le traitement paresseux est précieux, car il sépare la description d’un calcul du moment où ses données sont consommées. Cela convient aux entrées volumineuses et aux pipelines composables, tout comme les systèmes de flux évitent de conserver un jeu de données entier. Mais le code paresseux peut reporter les erreurs au moment de l’itération, parfois très loin de l’endroit où le générateur a été créé. Les développeurs devraient rendre explicites les points où les données sont consommées et se rappeler qu’un générateur est un processus à passage unique, pas une collection réutilisable.

Appariez les données selon leur forme pour rendre lisibles les interpréteurs et la manipulation des enregistrements

Laissez la structure guider le flux de contrôle. En Python, `match` et `case` peuvent examiner des séquences, des correspondances et des attributs de classe tout en associant les parties d’une valeur à des noms. Un motif de correspondance peut reconnaître un enregistrement de livre versionné sans exiger que toutes les clés sans rapport soient énumérées. Les motifs de séquence peuvent exprimer des structures imbriquées et recourir à des gardes pour des conditions supplémentaires.

Observez l’exemple d’interpréteur. Le petit interpréteur Scheme de Peter Norvig représente les expressions sous forme de listes Python imbriquées. La correspondance de motifs permet aux cas tels que les citations, les conditionnelles, les définitions de fonctions et les appels de ressembler aux données qu’ils traitent. Il est important de prévoir un cas fourre-tout: sans lui, une entrée mal formée peut traverser une instruction `match` sans qu’aucune action ne soit effectuée. Les motifs améliorent la clarté, mais leur ordre et leurs gardes constituent toujours une logique exécutable qui doit être testée.

Analyse

La correspondance de motifs est particulièrement efficace lorsque le code traduit des représentations structurées, car le flux de contrôle peut refléter la grammaire des données. Elle est donc utile pour les interpréteurs, les analyseurs et les enregistrements versionnés, et pas seulement comme une instruction switch plus élégante. Le danger consiste à prendre une correspondance de forme réussie pour une preuve de validité sémantique. Les gardes, les cas d’erreur explicites et les vérifications à l’exécution restent importants lorsque les données sont incomplètes ou proviennent de l’extérieur du programme.

Conservez le texte en Unicode à l’intérieur et spécifiez les encodages à chaque frontière

Distinguez les caractères des octets. En Python, `str` représente du texte Unicode; `bytes` représente des données encodées. Le mot « café » compte quatre caractères, mais occupe cinq octets en UTF-8, car « é » en prend deux. L’encodage convertit le texte en octets et le décodage convertit les octets en texte. L’approche « sandwich Unicode » (Unicode sandwich) décrite dans le livre consiste à décoder les données à leur arrivée dans un programme, à les traiter avec `str`, puis à les encoder uniquement à leur sortie.

Ne vous fiez jamais aux valeurs par défaut d’une plateforme. Écrire un fichier en UTF-8 puis le rouvrir avec une autre valeur par défaut peut transformer « café » en texte illisible. Le livre en fait la démonstration sous Windows, où CP1252 est utilisé par défaut. La normalisation Unicode est également nécessaire pour des comparaisons fiables: un caractère peut être représenté par un point de code précomposé ou par un caractère de base suivi d’un signe combinatoire. Une normalisation de compatibilité poussée peut modifier le sens; utilisez-la donc avec discernement.

Analyse

Les bogues liés au texte sont souvent des problèmes de frontière déguisés en problèmes de langue. Rendre l’encodage explicite transforme une hypothèse implicite liée à l’environnement en contrat d’interface visible, ce qui est particulièrement important lorsque des fichiers circulent entre différents systèmes. La normalisation ajoute une seconde difficulté : des textes d’apparence identique peuvent différer d’un octet à l’autre, mais un nettoyage trop agressif peut effacer des distinctions importantes pour les utilisateurs. La robustesse du traitement du texte exige donc à la fois une cohérence technique et une bonne compréhension de la langue et de la tâche.

Choisissez les threads pour l’attente, les processus pour le calcul et les coroutines pour les E/S coopératives

Adaptez la concurrence au goulot d’étranglement. Le verrou global de l’interpréteur (GIL) n’autorise qu’un seul thread Python à la fois à exécuter du code Python dans CPython; les threads n’accélèrent donc généralement pas les tâches Python gourmandes en calcul. Les processus peuvent utiliser plusieurs cœurs de processeur, mais leur démarrage et le transfert de données entre eux ont un coût. Les coroutines sont légères et peuvent gérer de nombreuses tâches en attente dans un seul thread, mais seulement si elles cèdent régulièrement le contrôle avec `await`.

Les exemples rendent le compromis concret. Le téléchargement de vingt drapeaux a pris environ 7,18 secondes de façon séquentielle, contre environ 1,40 seconde avec des threads et 1,35 seconde avec asyncio. Pour vérifier des nombres premiers dans une tâche gourmande en calcul, les processus surpassent les threads. Un appel bloquant à `time.sleep` dans une coroutine asyncio fige la boucle d’événements; il faut donc remplacer le travail bloquant par une opération asynchrone ou le déléguer à un exécuteur.

Analyse

Le chapitre s’oppose à l’idée trompeuse selon laquelle un outil de concurrence serait un bouton général d’accélération. Il distingue l’attente du calcul et prend en compte l’ensemble du système, notamment les coûts de communication et d’ordonnancement. Cette approche systémique est plus durable que la mémorisation d’un seul benchmark. Les coroutines réduisent le coût de la gestion de nombreuses tâches en attente, mais leur nature coopérative rend lourde de conséquences la moindre opération bloquante oubliée. Les choix de performance devraient se fonder sur des mesures de la charge de travail réelle, et non sur l’enthousiasme pour un modèle à la mode.

Utilisez les propriétés et la métaprogrammation pour éliminer les règles répétées, pas pour épater

Faites évoluer les attributs ordinaires en toute sécurité. Une propriété peut remplacer un champ public sans changer la manière dont les appelants le lisent ou lui attribuent une valeur. Dans l’exemple des aliments vendus en vrac, une propriété de poids rejette les valeurs nulles ou négatives tout en conservant `item.weight` comme interface. Un descripteur encapsule un comportement d’attribut réutilisable, tel que la règle `Quantity` utilisée à la fois pour le poids et le prix. La méthode ` set_name ` de Python peut attribuer automatiquement à chaque descripteur le nom de l’attribut qu’il gère.

Passez aux outils plus complexes avec prudence. Les décorateurs de classe et ` init_subclass ` peuvent configurer des classes avec moins de mécanismes qu’une métaclasse. Les métaclasses peuvent personnaliser la création même des classes, notamment ` slots `, mais elles ajoutent de la complexité liée au moment d’exécution et à l’héritage. Le conseil pratique du livre est de réserver ces outils aux bibliothèques et aux frameworks réutilisables, où l’élimination du travail répétitif justifie l’abstraction supplémentaire.

Analyse

La métaprogrammation est particulièrement convaincante lorsqu’elle transforme une règle répétée en un mécanisme unique et testable. Les exemples montrent que Python peut déplacer la validation et la configuration des classes hors du code applicatif sans imposer une nouvelle interface aux appelants. Pourtant, chaque mécanisme caché complique le débogage, car le comportement est assemblé indirectement. Le bon critère consiste à se demander si l’abstraction réduit la charge cognitive totale des utilisateurs comme des responsables de la maintenance, et non si le langage la rend possible.

Analyse

Programmer en Python est un guide technique organisé autour d’une thèse pratique: la maîtrise vient de la compréhension des contrats comportementaux intégrés au langage, puis du choix de l’outil le plus léger qui convienne. Le livre passe des séquences, des correspondances, du texte et des références d’objets aux fonctions, aux classes, aux protocoles, à la concurrence et à la métaprogrammation. Sa méthode pédagogique récurrente est concrète: un petit objet, comme un jeu de cartes ou un vecteur, est créé, testé et affiné jusqu’à ce qu’une caractéristique abstraite du langage ait une conséquence visible.

L’idée centrale qui unifie le mieux l’ensemble est que Python récompense l’interopérabilité. Une classe qui implémente un petit protocole peut immédiatement fonctionner avec une syntaxe et des bibliothèques pour lesquelles elle n’a jamais été explicitement conçue. Les fonctions de première classe réduisent le besoin de cérémonial, les générateurs permettent un traitement incrémental des données et les gestionnaires de contexte encodent le nettoyage autour d’un bloc. Ce ne sont pas des astuces isolées, mais des façons de laisser le langage prendre en charge les flux de contrôle répétitifs.

Le livre parle aussi avec une franchise inhabituelle des compromis. Les tuples peuvent contenir des objets mutables, les descripteurs peuvent masquer le comportement, les annotations de type peuvent donner une fausse confiance à propos de données non validées et l’héritage peut rendre fragile une réutilisation pourtant simple. Le traitement de la concurrence est tout aussi pragmatique: les threads conviennent à l’attente, les processus aux tâches gourmandes en calcul, et les coroutines ne restent réactives que si les appels bloquants sont exclus de la boucle d’événements.

L’ampleur du sujet est le principal défi que pose la synthèse du livre. Ses différentes parties peuvent ressembler à des manuels de référence distincts, et les chapitres ultérieurs supposent que le lecteur est à l’aise avec les notions présentées plus tôt. Pour en proposer la meilleure adaptation, il faut donc suivre la question de conception qui les sous-tend: de quel comportement l’appelant a-t-il besoin, quel protocole l’exprime, et quelle complexité est justifiée? Cette question transforme le livre, qui cesse d’être un catalogue de fonctionnalités Python pour devenir une méthode de conception de logiciels lisibles et interopérables. Il faut toutefois garder à l’esprit que le « style Python » ne se réduit pas à une liste de règles immuables. Les idiomes évoluent selon les versions et les charges de travail; la leçon durable est donc de comprendre la sémantique sous-jacente avant d’adopter un raccourci à la mode.

Résumé en 30 secondes
Les objets Python qui prennent en charge les protocoles standard s’utilisent naturellement avec la syntaxe et les bibliothèques intégrées. Les affectations partagent des références : les données mutables nécessitent donc des copies réfléchies ou des limites de propriété clairement définies. Les générateurs traitent les éléments à la demande, tandis que les fonctions peuvent remplacer nombre de classes de stratégie à méthode unique. Les threads conviennent à l’attente, les processus aux tâches très gourmandes en calcul et les coroutines aux entrées-sorties coopératives. Lors d’un test de téléchargement, la concurrence a réduit de 7,18 secondes à environ 1,4 seconde le temps nécessaire pour télécharger vingt images.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

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

Programmer en Python reçoit des critiques très largement positives, saluant sa couverture approfondie des sujets avancés de Python. Les lecteurs apprécient la clarté des explications, les exemples pratiques et les réflexions sur la philosophie de conception de Python. Beaucoup le considèrent comme indispensable aux programmeurs de niveau intermédiaire à avancé qui souhaitent approfondir leur compréhension du langage. Le livre se distingue par son approche exhaustive, qui aborde des sujets tels que les modèles de données, la concurrence et la métaprogrammation. Certains l’ont trouvé difficile, mais la plupart s’accordent à dire qu’il constitue une ressource précieuse pour maîtriser les subtilités de Python et écrire du code idiomatique.

Votre note :
4.71
305 évaluations
Envie de lire le livre complet ?

Glossaire

modèle de données de Python

Protocoles à la base de la syntaxe Python

L’ensemble des méthodes spéciales et des interfaces comportementales qui permettent aux objets de participer aux opérations Python. Implémenter des méthodes telles que __getitem__ ou __len__ peut permettre à un objet défini par l’utilisateur de prendre en charge l’indexation, l’itération ou len(). L’interpréteur appelle généralement ces méthodes en réponse à une syntaxe ou à des fonctions intégrées.

typage canard

Le type dépend du comportement pris en charge

Une façon d’utiliser les objets en fonction des opérations qu’ils fournissent plutôt que de leur classe déclarée. Si du code doit parcourir un objet, il peut essayer d’obtenir un itérateur au lieu d’exiger un type concret particulier. Cela favorise une collaboration flexible, même si les opérations non prises en charge peuvent échouer à l’exécution.

passage par partage

Les arguments partagent des références aux objets

Le mode de transmission des paramètres en Python : une fonction reçoit des références aux objets fournis par son appelant. Une fonction peut modifier un objet mutable partagé, auquel cas l’appelant voit ce changement, mais réaffecter le paramètre local ne réaffecte pas la variable de l’appelant. Cela explique à la fois les effets de bord liés aux arguments mutables et les bogues dus aux valeurs par défaut mutables.

système de types progressif

Vérification statique facultative des types

Un système de types qui permet de faire coexister du code Python annoté et non annoté. Des vérificateurs externes utilisent les indications de type pour repérer certaines erreurs probables sans modifier le comportement à l’exécution. En général, les annotations manquantes sont traitées avec souplesse, et les indications de type ne valident pas les valeurs réelles ni n’accélèrent l’exécution du programme.

protocole statique

Interface structurelle vérifiable

Un protocole défini avec typing.Protocol pour décrire les méthodes ou les attributs attendus par un vérificateur de types. Une classe n’a pas besoin d’hériter du protocole : elle est compatible si sa structure satisfait l’interface déclarée. Cela apporte la vérification statique au style de programmation de Python fondé sur le comportement.

descripteur

Gestionnaire d’attributs réutilisable

Un objet dont la classe implémente des méthodes telles que __get__, __set__ ou __delete__, ce qui lui permet de contrôler l’accès à un attribut d’une autre classe. Les propriétés reposent sur le mécanisme des descripteurs. Ceux-ci permettent de réutiliser la validation, les valeurs calculées et d’autres comportements liés aux attributs.

générateur

Itérateur à la demande

Un itérateur créé par une fonction génératrice contenant yield, ou par une expression génératrice. Il conserve son état d’exécution entre les valeurs produites et ne fournit l’élément suivant que lorsqu’on le demande. Cela permet un traitement paresseux sans construire une collection intermédiaire complète.

approche « sandwich Unicode » (Unicode sandwich)

Décoder à l’entrée, encoder à la sortie

Une pratique de traitement du texte qui consiste à décoder les octets entrants en chaînes Unicode à la frontière du système, à effectuer les traitements internes sur du texte et à n’encoder les données qu’au moment de les écrire ou de les transmettre. Elle réduit les mélanges accidentels d’octets et de texte et rend explicites les choix d’encodage à l’entrée comme à la sortie.

verrou global de l’interpréteur

Un seul thread Python s’exécute à la fois

Le GIL est un verrou de CPython qui n’autorise qu’un seul thread à la fois à exécuter du code Python. Les threads peuvent néanmoins être utiles pour les entrées-sorties, puisqu’ils passent du temps en attente, et certaines extensions libèrent le verrou. Pour répartir sur plusieurs cœurs les tâches Python intensives en calcul, il faut généralement utiliser des processus distincts.

gestionnaire de contexte

Gère la préparation et le nettoyage d’un bloc

Un objet utilisé par une instruction with pour effectuer la préparation à l’entrée et le nettoyage à la sortie. Le protocole synchrone utilise __enter__ et __exit__ ; les gestionnaires de contexte asynchrones utilisent __aenter__ et __aexit__. Un gestionnaire de contexte peut également traiter ou propager les exceptions levées à l’intérieur du bloc.

yield from

Délègue le travail d’un générateur

Une expression qui permet à un générateur de déléguer l’itération à un sous-générateur ou à un autre itérable. Les valeurs de la source déléguée sont transmises directement à l’appelant tandis que le générateur externe est suspendu. L’expression peut aussi récupérer la valeur de retour d’un sous-générateur, une fonctionnalité utilisée dans les modèles classiques de coroutines.

métaprogrammation des classes

Personnalisation des classes lors de leur création

Techniques permettant de créer ou de modifier des classes pendant l’exécution d’un programme. Les fabriques de classes, les décorateurs de classes, __init_subclass__ et les métaclasses offrent des degrés de contrôle croissants. Ces mécanismes sont utiles pour les frameworks réutilisables, mais peuvent rendre le code applicatif plus difficile à comprendre lorsque des outils plus simples suffiraient.

FAQ

De quoi parle Programmer en Python ?

  • Guide complet : Programmer en Python, de Luciano Ramalho, propose une exploration approfondie de la programmation en Python et met l’accent sur l’écriture d’un code clair, concis et efficace.
  • Sujets avancés : il traite de fonctionnalités avancées telles que les modèles de données, les décorateurs, les générateurs et la concurrence, ce qui le rend adapté aux développeurs expérimentés.
  • Approche pratique : le livre comprend des exemples pratiques et des exercices pour aider les lecteurs à appliquer efficacement les fonctionnalités de Python dans des situations concrètes.

Pourquoi lire Programmer en Python ?

  • Développer ses compétences : lire Programmer en Python vous aidera à devenir un programmeur Python plus compétent en vous faisant découvrir des concepts avancés et des bonnes pratiques.
  • Un Python idiomatique : le livre vous apprend à écrire du code idiomatique en Python, à la fois efficace et plus facile à lire et à maintenir.
  • Applications concrètes : les exemples et les exercices reflètent des défis réels de programmation, pour un apprentissage pertinent et applicable.

Quels sont les principaux enseignements de Programmer en Python ?

  • Comprendre le modèle de données de Python : l’un des principaux enseignements est l’importance de comprendre le modèle de données de Python, qui sous-tend le fonctionnement des objets et des classes.
  • L’importance des fonctions : le livre met en avant le rôle des fonctions de première classe et des fonctions d’ordre supérieur, qui permettent d’écrire du code plus flexible et réutilisable.
  • Programmation asynchrone : il traite en détail de la programmation asynchrone et explique comment écrire du code concurrent à l’aide de la bibliothèque asyncio.

Quelles sont les meilleures citations de Programmer en Python et que signifient-elles ?

  • « Python est un langage de programmation puissant et facile à apprendre. » : cette citation souligne l’accessibilité de Python pour les débutants tout en mettant en avant sa robustesse pour les développeurs expérimentés.
  • « Une abstraction prématurée est aussi néfaste qu’une optimisation prématurée. » : cette mise en garde invite à ne pas compliquer le code trop tôt et à privilégier d’abord un code clair et fonctionnel.
  • « Savoir ce qui est déjà prêt à l’emploi peut vous éviter de réinventer la roue. » : cette citation souligne l’importance d’utiliser la vaste bibliothèque standard de Python et ses fonctionnalités intégrées.

Comment Programmer en Python explique-t-il le modèle de données de Python ?

  • Concept central : le modèle de données de Python est un cadre qui formalise les interfaces des éléments constitutifs de Python, tels que les séquences, les fonctions et les classes.
  • Méthodes spéciales : il comprend des méthodes spéciales, souvent appelées méthodes « dunder », qui permettent aux objets d’interagir avec la syntaxe et les fonctions intégrées de Python.
  • Cohérence du comportement : en respectant le modèle de données, les programmeurs peuvent garantir que leurs objets personnalisés se comportent de manière cohérente avec les types intégrés de Python.

Quelle est l’importance des décorateurs dans Programmer en Python ?

  • Principes des décorateurs : les décorateurs sont des fonctions qui modifient le comportement d’autres fonctions ou méthodes et s’appliquent à l’aide de la syntaxe @decorator.
  • Fermetures et portée : comprendre les fermetures est essentiel pour les décorateurs, car ceux-ci doivent souvent accéder à des variables de leur portée englobante.
  • Exemples pratiques : le livre propose des exemples pratiques de décorateurs, notamment la création de décorateurs paramétrés qui acceptent des arguments.

Comment Programmer en Python aborde-t-il la programmation asynchrone ?

  • Bibliothèque asyncio : le livre présente un aperçu complet de la bibliothèque asyncio, indispensable pour écrire du code concurrent en Python.
  • Syntaxe async/await : il présente la syntaxe async/await et explique comment elle simplifie l’écriture de code asynchrone et en améliore la lisibilité.
  • Exemples pratiques : les lecteurs découvrent des exemples pratiques d’utilisation d’asyncio pour traiter efficacement les tâches à dominante entrées-sorties.

Que sont les générateurs et comment sont-ils utilisés dans Programmer en Python ?

  • Définition des générateurs : les générateurs sont un type d’itérable, défini au moyen de fonctions qui produisent des valeurs avec yield au lieu de les renvoyer, ce qui permet une évaluation paresseuse.
  • Efficacité mémoire : ils utilisent peu de mémoire, car ils produisent les éléments à la volée sans devoir stocker l’ensemble des données en mémoire.
  • Cas d’utilisation : le livre illustre diverses utilisations des générateurs, notamment les pipelines de traitement de données et la programmation asynchrone.

Comment Programmer en Python explique-t-il l’utilisation des indications de type ?

  • Typage progressif : le livre présente le concept de typage progressif, qui permet aux développeurs d’ajouter des indications de type sans imposer une vérification stricte des types.
  • Syntaxe des indications de type : il aborde leur syntaxe, notamment la façon d’annoter les paramètres et les valeurs de retour des fonctions.
  • Avantages des indications de type : elles améliorent la lisibilité du code et aident à repérer les erreurs liées aux types lors de l’analyse statique.

Quel est le rôle des métaclasses dans Programmer en Python ?

  • Fabriques de classes : les métaclasses sont présentées comme des fabriques de classes qui contrôlent la création et le comportement des classes.
  • Création dynamique de classes : elles permettent de personnaliser les attributs et les méthodes d’une classe au moment de sa création.
  • Usages avancés : bien qu’elles soient puissantes, les métaclasses conviennent mieux au développement de bibliothèques et de frameworks qu’au code applicatif courant.

Comment Programmer en Python aborde-t-il le concept de gestionnaire de contexte ?

  • Principes des gestionnaires de contexte : ils servent à gérer les ressources et garantissent leur acquisition et leur libération correctes.
  • Utilisation de l’instruction with : le livre insiste sur l’utilisation de l’instruction with pour simplifier la gestion des ressources.
  • Gestionnaires de contexte personnalisés : les lecteurs apprennent à créer leurs propres gestionnaires de contexte en implémentant les méthodes __enter__ et __exit__.

Quelle est la différence entre classmethod et staticmethod dans Programmer en Python ?

  • Rôle de classmethod : une méthode classmethod reçoit la classe comme premier argument, ce qui lui permet d’accéder aux attributs et aux méthodes de classe.
  • Rôle de staticmethod : une méthode staticmethod ne reçoit aucun premier argument spécial et se comporte comme une fonction ordinaire définie dans une classe.
  • Cas d’utilisation : classmethod convient aux méthodes qui doivent interagir avec la classe elle-même, tandis que staticmethod convient aux fonctions utilitaires liées à la classe.

À propos de l'auteur

Luciano Ramalho est un expert Python et un auteur très respecté. Reconnu pour sa profonde connaissance du langage, Ramalho a apporté une contribution importante à la communauté Python. Son style d’écriture est salué pour sa clarté, son attrait et sa qualité pédagogique. Les lecteurs apprécient sa capacité à expliquer des concepts complexes à l’aide d’exemples soigneusement élaborés, ainsi que ses réflexions sur les principes de conception de Python. Son expertise dépasse la syntaxe et englobe la philosophie du langage et les bonnes pratiques. Ses ouvrages incluent souvent un contexte historique et des comparaisons avec d’autres langages de programmation, offrant aux lecteurs une compréhension complète de la place de Python dans le monde de la programmation.

Télécharger le PDF

Pour garder le résumé de Programmer en 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 Programmer en 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 25 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ 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...