book

Fluent Python, 2ème édition

by Luciano Ramalho

November 2024

Intermediate to advanced

1014 pages

27h 21m

French

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

À qui s'adresse ce livreÀ qui ce livre ne s'adresse pasCinq livres en unComment le livre est organiséApproche pratiqueLa boîte à savon : Mon point de vue personnelSite Web du compagnon : fluentpython.comConventions utilisées dans ce livreUtiliser des exemples de codeApprentissage en ligne O'ReillyComment nous contacterRemerciementsRemerciements pour la première édition
Nouveautés de ce chapitreUn jeu de cartes PythonComment les méthodes spéciales sont-elles utilisées ?Emulation des types numériquesReprésentation des chaînes de caractèresValeur booléenne d'un type personnaliséAPI de collecteAperçu des méthodes spécialesPourquoi len n'est pas une méthodeRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreAperçu des séquences intégréesCompréhension des listes et expressions génératricesCompréhension des listes et lisibilitéListcomps Versus map and filterProduits cartésiensExpressions du générateurLes tuples ne sont pas seulement des listes immuablesLes tuples en tant qu'enregistrementsLes tuples en tant que listes immuablesComparaison des méthodes Tuple et ListeDécomposition des séquences et des itérabilitésUtilisation de * pour récupérer les éléments en tropDécompression avec * dans les appels de fonction et les séquences littéralesDéballage imbriquéCorrespondance de motifs avec des séquencesSéquences de correspondance de motifs dans un interprèteTrancherPourquoi les tranches et les plages excluent-elles le dernier élément ?Objets en tranchesTranchage multidimensionnel et ellipseAffectation à des tranchesUtilisation de + et * avec les séquencesConstruire des listes de listesAffectation augmentée avec des séquencesA += Casse-tête de l'affectationlist.sort Versus the sorted Built-InQuand une liste n'est pas la solutionTableauxVues de la mémoireNumPyDeques et autres files d'attenteRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreSyntaxe moderne des dictéesdict ComprehensionsDécomposition des mappagesFusionner les mappages avec |Correspondance de motifs avec les correspondancesAPI standard des types de mappageQu'est-ce que Hashable ?Aperçu des méthodes de cartographie courantesInsérer ou mettre à jour des valeurs mutablesTraitement automatique des clés manquantesdefaultdict : Un autre point de vue sur les clés manquantesLa méthode __missing__Utilisation incohérente de __missing__ dans la bibliothèque standardVariations de la dictéecollections.OrderedDictcollections.ChainMapcollections.Counterétagère.ShelfSous-classer UserDict au lieu de dictMappages immuablesVues du dictionnaireConséquences pratiques du fonctionnement de la dictéeThéorie des ensemblesEnsemble de lettresCompréhension des ensemblesConséquences pratiques du fonctionnement des ensemblesOpérations de réglageOpérations sur les vues en dictéeRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreQuestions relatives aux personnagesL'essentiel de l'octetEncodeurs/décodeurs de baseComprendre les problèmes de codage/décodageFaire face à l'erreur UnicodeEncodeErrorFaire face à l'erreur UnicodeDecodeErrorSyntaxError lors du chargement de modules avec un encodage inattenduComment découvrir le codage d'une séquence d'octets ?BOM : Un Gremlin utileTraitement des fichiers texteAttention aux valeurs par défaut du codageNormalisation de l'Unicode pour des comparaisons fiablesPliage de l'étuiFonctions d'utilité pour la correspondance de textes normalisésNormalisation extrême" : Suppression des diacritiquesTrier le texte UnicodeTri avec l'algorithme de collation UnicodeLa base de données UnicodeRecherche de personnages par leur nomSignification numérique des caractèresAPI à double mode pour les chaînes et les octetsstr versus bytes dans les expressions régulièresstr versus bytes dans les fonctions osRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreAperçu des constructeurs de classes de donnéesCaractéristiques principalesTuples nommés classiquesTuples nommés typésConseils d'écriture 101Pas d'effet sur le temps d'exécutionSyntaxe d'annotation des variablesLa signification des annotations de variablesEn savoir plus sur @dataclassOptions de champTraitement post-initAttributs des classes typéesVariables d'initialisation qui ne sont pas des champs@dataclass Exemple : Enregistrement de ressource Dublin CoreLa classe de données comme odeur de codeLa classe de données comme échafaudageLa classe de données comme représentation intermédiaireCorrespondance de motifs pour les instances de classeModèles de classes simplesModèles de classes de mots-clésModèles de classes positionnellesRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreLes variables ne sont pas des boîtesIdentité, égalité et aliasChoisir entre == et estL'immutabilité relative des tuplesLes copies sont superficielles par défautCopies profondes et superficielles d'objets arbitrairesParamètres de fonction comme référencesTypes mutables comme paramètres par défaut : Mauvaise idéeProgrammation défensive avec des paramètres mutablesdel et le ramassage des orduresTrucs et astuces de Python avec les immuablesRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreTraiter une fonction comme un objetFonctions d'ordre supérieurRemplacements modernes pour map, filter et reduceFonctions anonymesLes neuf saveurs des objets appelablesTypes d'appel définis par l'utilisateurDes paramètres positionnels aux paramètres par mot-clé uniquementParamètres positionnels uniquementPaquets pour la programmation fonctionnelleLe module opérateurGel des arguments avec functools.partialRésumé du chapitrePour en savoir plus

Nouveautés de ce chapitreÀ propos de la dactylographie graduelleLa dactylographie progressive en pratiqueCommencer avec MypyRendre Mypy plus strictA Valeur du paramètre par défautUtiliser None comme valeur par défautLes types sont définis par les opérations prises en chargeTypes utilisables dans les annotationsLe type AnyTypes et classes simplesTypes d'options et d'unionsCollections génériquesTypes de tupleMappages génériquesClasses de base abstraitesItérableGénériques paramétrés et TypeVarProtocoles statiquesAppelablePas de retourAnnotation des paramètres positionnels uniquement et des paramètres variablesLe typage imparfait et le test fortRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreDécorateurs 101Quand Python exécute les décorateursDécorateurs d'inscriptionRègles de portée des variablesFermeturesLa déclaration non localeLogique de recherche des variablesMise en place d'un décorateur simpleComment ça marcheLes décorateurs dans la bibliothèque standardMémorisation avec functools.cacheUtilisation de lru_cacheFonctions génériques à répartition uniqueDécorateurs paramétrésUn décorateur d'enregistrement paramétréLe décorateur d'horloge paramétréUn décorateur d'horloge basé sur les classesRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreÉtude de cas : Stratégie de refactorisationStratégie classiqueStratégie axée sur les fonctionsChoisir la meilleure stratégie : Approche simpleTrouver des stratégies dans un moduleModèle de stratégie amélioré par un décorateurLe modèle de commandeRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreReprésentations d'objetsClasse vectorielle ReduxUn constructeur alternatifclassmethod Versus staticmethodAffichages formatésUn vecteur hachable2dPrise en charge de la correspondance des motifs positionnelsListe complète de Vector2d, version 3Attributs privés et "protégés" en PythonÉconomiser de la mémoire avec __slots__Mesure simple des économies de __slot__Résumé des problèmes liés aux __slots__Remplacer les attributs de la classeRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreVecteur : Un type de séquence défini par l'utilisateurVector Take #1 : Compatible avec Vector2dProtocoles et typage de canardPrise vectorielle #2 : Une séquence à découper en tranchesComment fonctionne le découpage en tranchesUn __getitem__ adapté aux tranchesPrise de vecteur #3 : Accès dynamique aux attributsVector Take #4 : Hachage et un == plus rapidePrise vectorielle #5 : FormatageRésumé du chapitrePour en savoir plus
La carte dactylographiqueNouveautés de ce chapitreDeux types de protocolesProgrammation des canardsPython creuse les séquencesMonkey Patching : Implémentation d'un protocole au moment de l'exécutionProgrammation défensive et "Fail Fast"Dactylographie de l'oieSous-classement d'un ABCL'ABC de la bibliothèque standardDéfinir et utiliser un ABCDétails de la syntaxe ABCSous-classement d'un ABCUne sous-classe virtuelle d'un ABCUtilisation du registre dans la pratiqueLe typage structurel avec ABCProtocoles statiquesLa fonction double typéeProtocoles statiques vérifiables à l'exécutionLimites des contrôles de protocole en cours d'exécutionPrise en charge d'un protocole statiqueConception d'un protocole statiqueMeilleures pratiques pour la conception du protocoleExtension d'un protocoleL'ABC des chiffres et les protocoles numériquesRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreLa fonction super()La sous-classification des types intégrés est délicateHéritage multiple et ordre de résolution des méthodesClasses mixtesCorrespondances insensibles à la casseL'héritage multiple dans le monde réelLes ABC sont aussi des MixinsThreadingMixIn et ForkingMixInDjango Generic Views MixinsHéritage multiple dans TkinterFaire face à l'héritageFavoriser la composition d'objets plutôt que l'héritage de classesComprendre pourquoi l'héritage est utilisé dans chaque casRendre les interfaces explicites avec l'ABCUtilise des mixins explicites pour réutiliser le codeFournir des classes agrégées aux utilisateursSous-classe seulement Classes conçues pour la sous-classeÉviter de sous-classer des classes concrètesTkinter : Le bon, la brute et le truandRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreSignatures surchargéesSurcharge maximaleCe qu'il faut retenir de Overloading maxTypedDictType de moulageLire les indications de type au moment de l'exécutionProblèmes avec les annotations au moment de l'exécutionTraiter le problèmeImplémentation d'une classe génériqueJargon de base pour les types génériquesÉcartUn distributeur invariantUn distributeur covariantUne poubelle contravarianteExamen des dérogationsMise en oeuvre d'un protocole statique génériqueRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreSurcharge de l'opérateur 101Opérateurs unairesSurcharge du + pour l'addition vectorielleSurcharge de * pour la multiplication scalaireUtiliser @ comme opérateur infixeEnvelopper les opérateurs arithmétiquesOpérateurs de comparaison richesOpérateurs d'affectation augmentéeRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreUne séquence de motsPourquoi les séquences sont itérables : La fonction iterUtiliser iter avec un appelableItérables et itérateursClasses de phrases avec __iter__Prise de phrase #2 : Un itérateur classiqueNe fais pas de l'itérable un itérateur pour lui-mêmeExemple de phrase #3 : Une fonction génératriceComment fonctionne un générateurPhrases paresseusesPrise de phrase #4 : Générateur paresseuxPrise de phrase #5 : Expression du générateur paresseuxQuand utiliser les expressions du générateurUn générateur de progression arithmétiqueProgression arithmétique avec itertoolsFonctions du générateur dans la bibliothèque standardFonctions réductrices itérativesSous-générateurs avec un rendement deRéinventer la chaîneTraverser un arbreTypes génériques d'itérablesCoroutines classiquesExemple : Coroutine pour calculer une moyenne mobileRetourner une valeur à partir d'une CoroutineConseils sur les types génériques pour les coroutines classiquesRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreGestionnaires de contexte et blocsLes utilitaires contextlibUtilisation de @contextmanagerCorrespondance de motifs dans lis.py : Une étude de casSyntaxe de SchemeImportations et typesL'analyseurL'environnementLe REPLL'évaluateurProcédure : Une classe qui implémente une fermetureUtiliser les modèles ORFais ceci, puis cela : les blocs else au-delà de ifRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreVue d'ensembleUn peu de jargonProcessus, threads et l'infâme GIL de PythonUn Hello World concourantFilière avec filsRoue avec processusSpinner avec CoroutinesLes superviseurs côte à côteL'impact réel de l'EIGQuiz rapideUne réserve de processus maisonSolution basée sur les processusComprendre les temps écoulésCode pour le vérificateur d'amorces multicoreExpérimenter plus ou moins de processusNonsolution basée sur les filsPython dans le monde multicoreAdministration du systèmeScience des donnéesDéveloppement web/mobile côté serveurServeurs d'application WSGIFiles d'attente de tâches distribuéesRésumé du chapitrePour en savoir plusConcurrence avec les threads et les processusLe GILConcurrence au-delà de la bibliothèque standardConcurrence et évolutivité au-delà de Python
Nouveautés de ce chapitreTéléchargements Web simultanésUn script de téléchargement séquentielTéléchargement avec concurrent.futuresOù sont les futures ?Lancement de processus avec concurrent.futuresMulticore Prime Checker ReduxExpérimentation avec Executor.mapTéléchargements avec affichage de la progression et gestion des erreursGestion des erreurs dans les exemples de flags2Utilisation de futures.as_completedRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreQuelques définitionsUn exemple asyncio : Sonder les domainesL'astuce de Guido pour lire le code asynchroneNouveau concept : En attenteTélécharger avec asyncio et HTTPXLe secret des coroutines natives : Les humbles générateursLe problème du tout ou rienGestionnaires de contexte asynchronesAméliorer le téléchargeur asyncioUtilisation de asyncio.as_completed et d'un ThreadLimiter les demandes à l'aide d'un sémaphoreFaire plusieurs demandes pour chaque téléchargementDéléguer des tâches aux exécuteursÉcrire des serveurs asyncioUn service Web FastAPIUn serveur TCP asyncioItération asynchrone et tables d'itération asynchronesFonctions du générateur asynchroneCompréhensions asynchrones et expressions génératrices asynchronesasync Au-delà de l'asyncio : CurioIndication de type Objets asynchronesComment fonctionne l'asynchronisme et comment il ne fonctionne pasFaire le tour de la question du blocage des appelsLe mythe des systèmes liés aux E/SÉviter les pièges liés à l'unité centraleRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreTraitement des données avec les attributs dynamiquesExplorer les données de type JSON avec des attributs dynamiquesLe problème du nom d'attribut invalideCréation flexible d'objets avec __new__Propriétés calculéesÉtape 1 : Création d'attributs en fonction des donnéesÉtape 2 : Propriété pour récupérer un enregistrement liéÉtape 3 : Propriété remplaçant un attribut existantÉtape 4 : Cache des propriétés sur mesureÉtape 5 : Mise en cache des propriétés avec functoolsUtilisation d'une propriété pour la validation d'un attributLineItem Take #1 : Classe pour un article dans une commandeLineItem Take #2 : Une propriété de validationUn regard approprié sur les propriétésLes propriétés remplacent les attributs de l'instanceDocumentation sur les biensCodage d'une fabrique de propriétésGestion de la suppression des attributsAttributs et fonctions essentiels pour le traitement des attributs.Attributs spéciaux qui affectent le traitement des attributsFonctions intégrées pour la gestion des attributsMéthodes spéciales pour le traitement des attributsRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreExemple de descripteur : Validation des attributsLineItem Take #3 : Un simple descripteurLineItem Take #4 : Nommage automatique des attributs de stockageLineItem Take #5 : Un nouveau type de descripteurDescripteurs de surcharge et descripteurs de non-surchargeRemplacer les descripteursSurcharge du descripteur sans __get__Descripteur non dérogatoireEcraser un descripteur dans la classeLes méthodes sont des descripteursConseils sur l'utilisation des descripteursDocstring du descripteur et surcharge de la suppressionRésumé du chapitrePour en savoir plus
Nouveautés de ce chapitreLes classes en tant qu'objetstype : La fabrique de classes intégréeUne fonction d'usine de classeIntroduction de __init_subclass__Pourquoi __init_subclass__ ne peut pas configurer __slots__ ?Améliorer les classes avec un décorateur de classeCe qui se passe quand : Temps d'importation versus temps d'exécutionTemps d'évaluation ExpériencesMétaclasses 101Comment une métaclasse personnalise une classeUn bel exemple de métaclasseMétaclasse Évaluation Temps ExpérienceUne solution de métaclasse pour la vérificationLes métaclasses dans le monde réelLes caractéristiques modernes simplifient ou remplacent les métaclassesLes métaclasses sont des caractéristiques linguistiques stablesUne classe ne peut avoir qu'une seule métaclasseLes métaclasses devraient être des détails d'implémentationUn hack de métaclasse avec __prepare__Pour conclureRésumé du chapitrePour en savoir plus
Pour en savoir plus

Content preview from Fluent Python, 2ème édition

Chapitre 24. Métaprogrammation des classes

Cet ouvrage a été traduit à l'aide de l'IA. Tes réactions et tes commentaires sont les bienvenus : translation-feedback@oreilly.com

Tout le monde sait que le débogage est deux fois plus difficile que l'écriture d'un programme. Alors si tu es aussi intelligent que possible lorsque tu l'écris, comment pourras-tu jamais le déboguer ?

Brian W. Kernighan et P. J. Plauger, Les éléments du style de programmation¹

Métaprogrammation des classes est l'art de créer ou de personnaliser des classes au moment de l'exécution. Les classes sont des objets de première classe en Python, une fonction peut donc être utilisée pour créer une nouvelle classe à tout moment, sans utiliser le mot-clé class. Les décorateurs de classe sont également des fonctions, mais conçues pour inspecter, modifier et même remplacer la classe décorée par une autre classe. Enfin, les métaclasses sont l'outil le plus avancé pour la métaprogrammation des classes : elles te permettent de créer de toutes nouvelles catégories de classes avec des traits particuliers, comme les classes de base abstraites que nous avons déjà vues.

Les métaclasses sont puissantes, mais difficiles à justifier et encore plus difficiles à mettre en place. Les décorateurs de classe résolvent une grande partie des mêmes problèmes et sont plus faciles à comprendre. De plus, Python 3.6 a mis en œuvre laPEP 487-Personnalisation plus simple de la création de classes, en fournissant des méthodes spéciales prenant ...