Programmer avec Python

Table of contents

1. Couverture
2. Programmer en Python - Apprendre la programmation de façon claire, concise et efficace - collection O'Reilly
3. Copyright
4. Préface
   1. À qui s’adresse ce livre
   2. Pour qui ce livre n’est pas
   3. Comment est organisé ce livre
   4. En pratique…
   5. Matériel utilisé pour les tests
   6. Boîte à savon (mon point de vue personnel)
   7. Lexique Python
   8. Quelle(s) version(s) de Python utiliser ?
   9. Conventions utilisées dans ce livre
   10. Utiliser les exemples de code
5. PARTIE I. Prologue
   1. CHAPITRE 1. Le modèle de données de Python
      1. Un jeu de cartes Pythonique
      2. Comment les méthodes spéciales sont utilisées
         1. Émuler des types numériques
         2. Représentation de chaîne de caractères
         3. Opérateurs arithmétiques
         4. Valeur booléenne d’un type personnalisé
      3. Aperçu des méthodes spéciales
      4. Pourquoi len n’est pas une méthode
      5. Résumé du chapitre
      6. Lectures complémentaires
6. PARTIE II. Structures de données
   1. CHAPITRE 2. Un réseau de séquences
      1. Généralités sur les séquences natives
      2. Compréhensions de listes et expressions générateurs
         1. Compréhensions de listes et lisibilité
         2. Listcomps versus map et filter
         3. Produits cartésiens
         4. Expressions générateurs
      3. Les tuples ne sont pas seulement des listes immuables
         1. Les tuples en tant qu’enregistrements
         2. Déballage de tuple
            1. Utiliser * pour capturer les éléments en excès
         3. Déballage de tuples imbriqués
         4. Tuples nommés
         5. Les tuples en tant que listes immuables
      4. Tranchage
         1. Pourquoi les tranches et les intervalles excluent le dernier élément
         2. Objets slice (ou tranches)
         3. Tranchage multidimensionnel et ellipse
         4. Affectation aux tranches
      5. Utilisation de + et * avec les séquences
         1. Création de listes de listes
      6. Affectation augmentée avec les séquences
         1. L’énigme de l’affectation +=
      7. list.sort et la fonction native sorted
      8. Gérer les séquences ordonnées avec bisect
         1. Recherche avec bisect
         2. Insertion avec bisect.insort
      9. Quand une liste n’est pas la réponse
         1. Tableaux
         2. Vues sur la mémoire
         3. NumPy et SciPy
         4. Deque et autres files
      10. Résumé du chapitre
      11. Lectures complémentaires
   2. CHAPITRE 3. Dictionnaires et ensembles
      1. Types de mappage génériques
      2. Compréhensions de dictionnaires
      3. Aperçu des méthodes de mappage courantes
         1. Gérer les clés manquantes avec setdefault
      4. Mappages avec recherche de clé souple
         1. defaultdict : un autre regard sur les clés manquantes
         2. La méthode __missing__
         3. Variantes autour du dictionnaire
      5. Sous-classer UserDict
      6. Mappages immuables
      7. Théorie des ensembles
         1. Littéraux set
         2. Compréhensions d’ensembles
         3. Opérations sur les ensembles
      8. dict et set : levons le capot
         1. Une expérience de performances
         2. Tables de hachage dans les dictionnaires
            1. Hachages et égalité
            2. L’algorithme de la table de hachage
         3. Conséquences pratiques du mode de fonctionnement des dict
            1. Les clés doivent être des objets hachables
            2. Les dict ont une surcharge de mémoire d’une certaine ampleur
            3. La recherche de clés est très rapide
            4. L’ordre des clés dépend de l’ordre d’insertion
            5. L’ajout d’éléments à un dict peut modifier l’ordre des clés existantes
         4. Conséquences pratiques du fonctionnement des ensembles
      9. Résumé du chapitre
      10. Lectures complémentaires
   3. CHAPITRE 4. Texte contre octets
      1. Questions de caractère
      2. L’essentiel sur les octets
         1. Structures et vues mémoire
      3. Codeurs/décodeurs de base
      4. Comprendre les problèmes d’encodage/décodage
         1. Faire face aux erreurs UnicodeEncodeError
         2. Faire face aux erreurs UnicodeDecodeError
         3. Erreur de syntaxe lors du chargement de modules avec un encodage inattendu
         4. Comment découvrir l’encodage d’une séquence d’octets
         5. BOM : un gremlin utile
      5. Gestion des fichiers de texte
         1. Encodages par défaut : une maison de fous !
      6. Normaliser Unicode pour des comparaisons plus sûres
         1. Pliage de casse
         2. Fonctions utilitaires pour la correspondance de textes normalisés
         3. « Normalisation » extrême : suppression des diacritiques
      7. Trier du texte Unicode
         1. Tri avec l’algorithme de classement Unicode
      8. La base de données Unicode
      9. API dual-mode str et bytes
         1. str versus bytes dans les expressions rationnelles
         2. str versus bytes dans les fonctions du module os
      10. Résumé du chapitre
      11. Lectures complémentaires
7. PARTIE III. Les fonctions en tant qu'objets
   1. CHAPITRE 5. Fonctions de première classe
      1. Traiter une fonction comme un objet
      2. Fonctions d’ordre supérieur
         1. Remplacements modernes pour map, filter et reduce
      3. Fonctions anonymes
      4. Les sept saveurs des objets appelables
      5. Types d’appelables définis par l’utilisateur
      6. Introspection de fonctions
      7. Paramètres positionnels et paramètres nommés
      8. Récupérer des informations sur les paramètres
      9. Annotations de fonction
      10. Packages pour la programmation fonctionnelle
          1. Le module operator
          2. Geler des arguments avec functools.partial
      11. Résumé du chapitre
      12. Lectures complémentaires
   2. CHAPITRE 6. Patrons de conception avec des fonctions de première classe
      1. Étude de cas : le patron Strategy
         1. Stratégie classique
         2. Stratégie axée sur les fonctions
         3. Choisir la meilleure stratégie : approche simple
         4. Rechercher des stratégies dans un module
      2. Command
      3. Résumé du chapitre
      4. Lectures complémentaires
   3. CHAPITRE 7. Décorateurs et fermetures de fonctions
      1. Décorateurs 101
      2. Exécution des décorateurs par Python
      3. Patron de stratégie amélioré par un décorateur
      4. Règles relatives à la portée variable
      5. Fermetures
      6. La déclaration nonlocal
      7. Implémenter un décorateur simple
         1. Comment ça marche
      8. Décorateurs dans la bibliothèque standard
         1. Mémoïsation avec functools.lru_cache
         2. Fonctions génériques avec singledispatch
      9. Décorateurs empilés
      10. Décorateurs paramétrés
          1. Un décorateur d’enregistrement paramétré
          2. Paramétrage du décorateur clock
      11. Résumé du chapitre
      12. Lectures complémentaires
8. PARTIE IV. Idiomes orientés objet
   1. CHAPITRE 8. Références d’objets, muabilité, et recyclage
      1. Les variables ne sont pas des boîtes
      2. Identité, égalité et alias
         1. Choisir entre == et is
         2. L’immuabilité relative des tuples
      3. Les copies sont superficielles par défaut
         1. Copies récursives et superficielles d’objets arbitraires
      4. Paramètres de fonction comme références
         1. Types muables comme paramètres par défaut : mauvaise idée
         2. Programmation défensive avec des paramètres muables
         3. del et le ramasse-miettes
      5. Références faibles
         1. Le scénario WeakValueDictionary
         2. Limites des références faibles
      6. Quand Python joue avec les immuables
      7. Résumé du chapitre
      8. Lectures complémentaires
   2. CHAPITRE 9. Un objet Pythonique
      1. Représentations d’objets
      2. Retour vers la classe vectorielle
      3. Un constructeur alternatif
      4. Classmethod versus staticmethod
      5. Affichages formatés
      6. Un Vector2d hachable
      7. Attributs privés et « protégés » en Python
      8. Gagner de l’espace avec l’attribut de classe __slots__
         1. Les problèmes avec __slots__
      9. Remplacer les attributs de classe
      10. Résumé du chapitre
      11. Lectures complémentaires
   3. CHAPITRE 10. Piratage de séquence, hachage et tranchage
      1. Vector : un type de séquence défini par l’utilisateur
      2. Vector, Prise #1 : compatibilité avec Vector2d
      3. Protocoles et duck typing
      4. Vector, Prise #2 : une séquence tranchable
         1. Comment fonctionne le tranchage
         2. Un __getitem__ soucieux des tranches
      5. Vector, Prise #3 : accès dynamique aux attributs
      6. Vector, Prise #4 : hachage et un == plus rapide
      7. Vector, Prise #5 : formatage
      8. Résumé du chapitre
      9. Lectures complémentaires
   4. CHAPITRE 11. Interfaces : des protocoles aux ABC
      1. Interfaces et protocoles dans la culture Python
      2. Python et les séquences
      3. Monkey patching pour implémenter un protocole lors de l’exécution
      4. La sauvagine d’Alex Martelli
      5. Sous-classer une ABC
      6. Les ABC dans la bibliothèque standard
         1. Les ABC dans collections.abc
         2. La tour numérique
      7. Définir et utiliser une ABC
         1. Détails de la syntaxe des ABC
         2. Sous-classer l’ABCTombola
         3. Une sous-classe virtuelle de Tombola
      8. Comment les sous-classes de Tombola ont été testées
      9. Utiliser register dans la pratique
      10. Les oies peuvent se comporter comme des canards
      11. Résumé du chapitre
      12. Lectures complémentaires
   5. CHAPITRE 12. Héritage : pour le meilleur ou pour le pire
      1. Le sous-classement des types natifs est délicat
      2. Héritage multiple et ordre de résolution de méthode
      3. Héritage multiple dans le monde réel
      4. Faire face à l’héritage multiple
         1. 1. Distinguer l’héritage d’interface de l’héritage d’implémentation
         2. 2. Rendre les interfaces explicites avec les ABC
         3. 3. Utilisation des mixins pour la réutilisation du code
         4. 4. Rendre les mixins explicites en les nommant
         5. 5. Une ABC peut aussi être un mixin ; l’inverse n’est pas vrai
         6. 6. Ne pas sous-classer depuis plus d’une classe concrète
         7. 7. Fournir des classes agrégées aux utilisateurs
         8. 8. « Favoriser la composition des objets plutôt que l’héritage de classe »
         9. Tkinter : le bon, le mauvais et le laid
      5. Un exemple moderne : les mixins dans les vues génériques de Django
      6. Résumé du chapitre
      7. Lectures complémentaires
   6. CHAPITRE 13. Surcharge des opérateurs : bien faire les choses
      1. Surcharge des opérateurs 101
      2. Opérateurs unaires
      3. Surcharger + pour l’addition de vecteurs
      4. Surcharger * pour la multiplication scalaire
      5. Opérateurs de comparaison riches
      6. Opérateurs d’affectation augmentée
      7. Résumé du chapitre
      8. Lectures complémentaires
9. PARTIE V. Contrôler les flux
   1. CHAPITRE 14. Itérables, itérateurs et générateurs
      1. Sentence, Prise #1 : une séquence de mots
         1. Pourquoi les séquences sont itérables : la fonction iter
      2. Les itérables versus les itérateurs
      3. Sentence, Prise #2 : un itérateur classique
         1. Faire de Sentence un itérateur est une mauvaise idée
      4. Sentence, Prise #3 : une fonction générateur
         1. Comment marche une fonction générateur
      5. Sentence, Prise #4 : une implémentation paresseuse
      6. Sentence, Prise #5 : une expression générateur
      7. Quand utiliser les expressions générateurs
      8. Un autre exemple : générateur de progression arithmétique
         1. Progression arithmétique avec itertools
      9. Fonctions générateurs dans la bibliothèque standard
         1. Nouvelle syntaxe apparue dans Python 3.3 : yield from
      10. Fonctions de réduction des itérables
      11. Observer de plus près la fonction iter
      12. Étude de cas : générateurs dans un utilitaire de conversion de base de données
      13. Les générateurs comme coroutines
      14. Résumé du chapitre
      15. Lectures complémentaires
   2. CHAPITRE 15. Gestionnaires de contexte et autres blocs
      1. Fait cela, puis ceci : les blocs else au-delà de if
      2. Gestionnaires de contexte et blocs with
      3. Les utilitaires contextlib
      4. Utiliser @contextmanager
      5. Résumé du chapitre
      6. Lectures complémentaires
   3. CHAPITRE 16. Coroutines
      1. Comment les coroutines ont évolué à partir des générateurs
      2. Comportement de base d’un générateur utilisé comme coroutine
      3. Exemple de coroutine pour calculer une moyenne mobile
      4. Décorateurs pour amorcer les coroutines
      5. Terminer une coroutine et gérer les exceptions
      6. Retourner une valeur à partir d’une coroutine
      7. Utiliser yield from
      8. La signification de yield from
      9. Cas d’utilisation : des coroutines pour la simulation à événements discrets
         1. À propos des simulations à événements discrets
         2. Simuler une flotte de taxis
      10. Résumé du chapitre
      11. Lectures complémentaires
   4. CHAPITRE 17. Programmation concurrente avec les futurs
      1. Exemple : téléchargements Web en trois styles
         1. Un script de téléchargement séquentiel
         2. Téléchargement avec concurrent.futures
         3. Où sont les futurs ?
      2. Blocage des E/S du GIL
      3. Lancement de processus avec concurrent.futures
      4. Expériences avec Executor.map
      5. Téléchargements avec affichage de la progression et gestion des erreurs
         1. Gestion des erreurs dans les exemples flags2
         2. Utiliser futures.as_completed
         3. Alternatives aux threads et aux processus multiples
      6. Résumé du chapitre
      7. Lectures complémentaires
   5. CHAPITRE 18. Concurrence avec asyncio
      1. Thread versus coroutine : une comparaison
         1. asyncio.Future : non bloquante par conception
         2. Yield from et futurs, tâches et coroutines
      2. Téléchargement avec asyncio et aiohttp
      3. Débloquer les appels bloquants
      4. Améliorer le script de téléchargement de asyncio
         1. Utiliser asyncio.as_completed
         2. Utiliser un exécuteur pour éviter de bloquer la boucle d’événements
      5. Des rappels aux futurs et aux coroutines
         1. Effectuer plusieurs requêtes pour chaque téléchargement
      6. Écrire des serveurs avec asyncio
         1. Un serveur TCP asyncio
         2. Un serveur Web aiohttp
         3. Des clients plus intelligents pour une meilleure concurrence
      7. Résumé du chapitre
      8. Lectures complémentaires
10. PARTIE VI. Métaprogrammation
    1. CHAPITRE 19. Attributs et propriétés dynamiques
       1. Préparer des données avec des attributs dynamiques
          1. Explorer des données de type JSON avec des attributs dynamiques
          2. Le problème du nom d’attribut invalide
          3. Création d’objets flexible avec __new__
          4. Restructurer le flux de l’OSCON avec shelve
          5. Récupération d’enregistrements liés avec leurs propriétés
       2. Utiliser une propriété pour valider des attributs
          1. LineItem, Prise #1 : une classe pour un article dans une commande
          2. LineItem, Prise #2 : une propriété de validation
       3. Un regard approprié sur les propriétés
          1. Remplacer les attributs d’instance
          2. Documenter les propriétés
       4. Coder une factory de propriétés
       5. Gérer la suppression d’attributs
       6. Attributs et fonctions essentiels pour le traitement des attributs
          1. Attributs spéciaux qui affectent la gestion des attributs
          2. Fonctions natives pour la gestion des attributs
          3. Méthodes spéciales pour la gestion des attributs
       7. Résumé du chapitre
       8. Lectures complémentaires
    2. CHAPITRE 20. Descripteurs d’attributs
       1. Exemple de descripteur : validation des attributs
          1. LineItem, Prise #3 : un descripteur simple
          2. LineItem, Prise #4 : noms des attributs de stockage automatiques
          3. LineItem, Prise #5 : un nouveau type de descripteur
       2. Descripteurs prioritaires et non prioritaires
          1. Descripteur prioritaire
          2. Descripteur prioritaire sans __get__
          3. Descripteur non prioritaire
          4. Remplacement d’un descripteur dans la classe
       3. Les méthodes sont des descripteurs
       4. Conseils pour l’utilisation des descripteurs
       5. Docstring de descripteur et suppression d’attributs gérés
       6. Résumé du chapitre
       7. Lectures complémentaires
    3. CHAPITRE 21. Métaprogrammation de classe
       1. Class factory !
       2. Un décorateur de classe pour personnaliser des descripteurs
       3. Que se passe-t-il et quand : importation versus exécution
          1. Des exercices pour évaluer le temps
             1. Solution pour le scénario #1
             2. Solution pour le scénario #2
       4. Métaclasses 101
          1. L’exercice d’évaluation du temps, version métaclasse
             1. Solution pour le scénario # 3
             2. Solution pour le scénario #4
       5. Une métaclasse pour personnaliser les descripteurs
       6. Les métaclasses et la méthode spéciale __prepare__
       7. Classes en tant qu’objets
       8. Résumé du chapitre
       9. Lectures complémentaires
11. Postface
    1. Lectures complémentaires
12. ANNEXE A. Scripts de support
    1. Chapitre 3 : Test de performance de l’opérateur in
    2. Chapitre 3 : Comparaison des trames de bits de hachage
    3. Chapitre 9 : Utilisation de la RAM avec et sans __slots__
    4. Chapitre 14 : Script de conversion de base de données isis2json.py
    5. Chapitre 16 : Simulation d’événements d’une flotte de taxis
    6. Chapitre 17 : Exemples cryptographiques
    7. Chapitre 17 : Exemples de client http flags2
    8. Chapitre 19 : Scripts et tests de programmation OSCON
13. Lexique Python
14. Sommaire