Python 3 : traitement de données et techniques de programmation

Auteur(s) :

Chazallet, Sébastien (1980-....) Découvrir l'auteur

Résumé

La première partie du livre détaille le traitement des données avec la manipulation de fichiers. La deuxième partie porte sur les divers types de programmation : système, réseau, web et scientifique. La troisième partie présente tous les outils de programmation concurrente, dont la programmation asynchrone. Des compléments sont accessibles en ligne. ©Electre 2020

Éditeur(s)
- Éditions ENI
Date
- cop. 2020
Notes
- La couv. porte en plus :"En téléchargement : code source des exemples" ; "Version en ligne offerte ! pendant 1 an" ; "Informatique technique"
- La 4e de couv. porte en plus : "Sur www.editions-eni.fr : le code source des exemples"
- Conrient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (448 p.) : ill. ; 22 cm
Collections
- Expert IT
Sujet(s)
ISBN
- 978-2-409-02292-0
Indice
- 681.234 Python
Quatrième de couverture
- Python 3
  Traitement de données et techniques de programmation
  Ce livre sur le langage Python 3 (en version 3.8 beta au moment de l'écriture) s'adresse à tout professionnel de l'informatique, ingénieur, étudiant, enseignant ou même autodidacte qui souhaite maîtriser ce langage très abouti. L'objectif de ce livre est de montrer au lecteur ce que l'on peut faire avec le langage, du traitement de données à la création d'un site web, en passant par la gestion du système et du réseau. Pour bien appréhender son contenu, la lecture du livre dont il est la suite, Python 3 - Les fondamentaux du langage chez le même éditeur, est recommandée.
  La première partie couvre le traitement de données avec la manipulation de fichiers, les fichiers de configuration, les formats d'import/export, la gestion de la compression ou encore les flux XML ou la génération de documents.
  La seconde partie présente la programmation système, la programmation réseau, la programmation web et la programmation scientifique, qui sont autant de niches dans lesquelles le langage Python excelle par sa simplicité d'utilisation autant que par sa couverture fonctionnelle exceptionnelle.
  La troisième partie présente tous les outils de programmation concurrente, qu'il s'agisse de programmation asynchrone, parallèle ou distribuée. On notera que l'accent est mis sur de nombreuses techniques asynchrones, car il s'agit de l'un des points majeurs de l'évolution récente du langage Python.
  Le code source des exemples du livre est intégralement téléchargeable sur www.editions-eni.fr pour permettre au lecteur de tester le programme et de le modifier à sa guise de manière à faire ses propres expériences.
Tables des matières
- - Python 3
  - Traitement de données et techniques de programmation
  - Avant-propos
  - Partie 1
    Traitement des données
  - Chapitre 1.1
    Motifs de conception
  - 1. Définition15
  - 1.1 Positionnement par rapport à la notion d'objet15
  - 1.2 Organisation du chapitre16
  - 1.3 Positionnement par rapport à d'autres concepts16
  - 2. Motifs de création17
  - 2.1 Singleton17
  - 2.2 Fabrique17
  - 2.3 Fabrique abstraite20
  - 2.4 Monteur21
  - 2.5 Prototype23
  - 3. Motifs de structuration26
  - 3.1 Adaptateur26
  - 3.2 Pont29
  - 3.3 Composite32
  - 3.4 Décorateur34
  - 3.5 Façade36
  - 3.6 Poids-mouche38
  - 3.7 Proxy40
  - 4. Motifs de comportement42
  - 4.1 Chaîne de responsabilité42
  - 4.2 Commande43
  - 4.3 Itérateur45
  - 4.4 Mémento47
  - 4.5 Visiteur48
  - 4.6 Observateur49
  - 4.7 Stratégie51
  - 4.8 Fonction de rappel52
  - 5. ZCA53
  - 5.1 Rappels53
  - 5.2 Adaptateur53
  - 5.3 Utilitaire55
  - 5.4 Fabrique56
  - 5.5 Pour aller plus loin57
  - Chapitre 1.2
    XML
  - 1. XML et les technologies qui gravitent autour59
  - 1.1 Définition de XML, terminologie associée59
  - 1.2 Notion de schéma60
  - 1.3 Avantages et inconvénients de XML61
  - 1.4 Différentes manières de parcourir un fichier XML62
  - 1.5 Modules Python dédiés au XML62
  - 2. Valider un document XML63
  - 2.1 Document XML63
  - 2.2 Schéma DTD64
  - 2.3 Schéma XSD64
  - 2.4 Schéma RNG (RelaxNG)65
  - 2.5 Schematron65
  - 3. DOM66
  - 3.1 Lecture66
  - 3.2 Écriture67
  - 4. SAX68
  - 4.1 Support de SAX dans lxml68
  - 4.2 API SAX Allégée69
  - 5. XPath70
  - 6. XSLT72
  - 7. Cas spécifique des fichiers HTML74
  - 7.1 Problématique74
  - 7.2 Parser un fichier HTML à la façon DOM74
  - 7.3 Parser un fichier HTML à la façon SAX76
  - Chapitre 1.3
    Génération de contenu
  - 1. PDF79
  - 1.1 Présentation79
  - 1.1.1 Format PDF79
  - 1.1.2 Avantages79
  - 1.1.3 Inconvénients79
  - 1.1.4 Présentation de la bibliothèque libre80
  - 1.2 Bas niveau80
  - 1.2.1 Bibliothèque de données80
  - 1.2.2. Canvas82
  - 1.3 Haut niveau83
  - 1.3.1 Styles83
  - 1.3.2 Flux de données85
  - 1.3.3 Création d'un visuel87
  - 1.3.4 Template de page87
  - 1.3.5 Page contenant plusieurs zones88
  - 2. OpenDocument90
  - 2.1 Présentation90
  - 2.2 ezodf291
  - 2.2.1 Installation91
  - 2.2.2 OpenDocument Texte91
  - 2.2.3 OpenDocument Tableur91
  - 2.2.4 Aller plus loin92
  - 2.3 Alternatives92
  - 2.3.1 Ipod92
  - 2.3.2 Génération à partir de templates92
  - 3. Travailler avec des images93
  - 3.1 Représentation informatique d'une image93
  - 3.2 Présentation de Pillow94
  - 3.3 Formats d'images matricielles95
  - 3.4 Récupérer des informations d'une image97
  - 3.5 Opérations d'ensemble sur une image98
  - 3.6 Travailler avec les calques ou les pixels100
  - Chapitre 1.4
    Qualité
  - 1. Programmation dirigée par les tests103
  - 1.1 Tests unitaires103
  - 1.1.1 Principes103
  - 1.1.2 Interprétation104
  - 1.1.3 Couverture105
  - 1.1.4 Outils105
  - 1.1.5 Autres outils107
  - 1.2 Tests de non-régression107
  - 1.2.1 Actions de développement107
  - 1.2.2 Gestion de la découverte d'une anomalie par une MOA108
  - 1.3 Tests fonctionnels109
  - 1.4 Tests de performance110
  - 1.5 Tests syntaxiques112
  - 1.6 Intégration continue113
  - 2. Programmation dirigée par la documentation114
  - 2.1 Documentation interne114
  - 2.1.1 À destination des développeurs114
  - 2.1.2 À destination des utilisateurs115
  - 2.2. Documentation externe115
  - 2.2.1 Présentation115
  - 2.2.2 Démarrage rapide115
  - 2.2.3 Résultat118
  - 3. Optimisation118
  - 3.1 Qualimétrie118
  - 3.2 Outils de débogage120
  - 3.3 Outils de profilage120
  - 3.4 Règles d'optimisation122
  - 3.4.1 Pourquoi optimiser ?122
  - 3.4.2 Règles générales123
  - 3.4.3 Profiler un algorithme124
  - 3.4.4 Optimiser l'utilisation de la mémoire133
  - Partie 2
    Programmation, système, réseau et scientifique
  - Chapitre 2.1
    Programmation système
  - 1. Présentation135
  - 1.1 Définition135
  - 1.2 Objectifs du chapitre136
  - 2. Appréhender son système d'exploitation136
  - 2.1 Avertissement136
  - 2.2 Système d'exploitation136
  - 2.3 Processus courant137
  - 2.4 Utilisateurs et groupes138
  - 2.5 Mots de passe et authentification140
  - 2.6 Constantes pour le système de fichiers141
  - 2.7 Gérer les chemins142
  - 2.8 Utilitaires142
  - 2.8.1 Comparer deux fichiers142
  - 2.8.2 Utilitaire de sauvegarde144
  - 2.8.3 Lire un fichier de configuration145
  - 2.8.4 Pickle146
  - 2.9 Compresser et décompresser un fichier148
  - 2.9.1 Tarfile148
  - 2.9.2 Gzip150
  - 2.9.3 Bz2151
  - 2.9.4 Zipfile151
  - 2.9.5 Interface de haut niveau153
  - 3. Gestion d'un fichier154
  - 3.1 Changer les droits d'un fichier154
  - 3.2 Changer de propriétaire ou de groupe156
  - 3.3 Récupérer des informations sur un fichier157
  - 3.4 Supprimer un fichier157
  - 4. Alternatives simples à des commandes bash usuelles158
  - 4.1 Répertoires158
  - 4.2 Fichiers160
  - 4.3 Module de haut niveau161
  - 4.4 Recherche d'un fichier163
  - 5. Exécuter des commandes externes164
  - 5.1 Exécuter et afficher le résultat164
  - 5.2 Exécuter et récupérer le résultat165
  - 5.3 Pour Python 3.5 et supérieur166
  - 6. IHM système166
  - 6.1 Présentation166
  - 6.2 Travailler avec des arguments167
  - 6.3 Fermeture du programme171
  - 6.4 Entrée standard172
  - 6.5 Sortie standard173
  - 6.6 Sortie d'erreur174
  - 6.7 Taille du terminal175
  - 7. Curses176
  - 7.1 Présentation176
  - 7.2 Gérer le démarrage et l'arrêt176
  - 7.3 Affichage de texte177
  - 7.4 Gestion des attributs177
  - 7.5 Gestion des couleurs178
  - 7.6 Gestion des événements178
  - 8. Accès aux périphériques178
  - 8.1 Introduction179
  - 8.2 Voir les partitions179
  - 8.3 Voir les clés USB180
  - 8.4 Liste des informations disponibles181
  - 8.5 Détecter le branchement d'une clé USB181
  - 8.6 Communiquer via un port série182
  - 8.7 Communiquer via un port USB183
  - Chapitre 2.2
    Programmation réseau
  - 1. Écrire un serveur et un client185
  - 1.1 Utilisation d'un socket TCP185
  - 1.2 Utilisation d'une socket UDP189
  - 1.3 Création d'un serveur TCP191
  - 1.4 Création d'un serveur UDP193
  - 1.5 Un peu plus loin sur le sujet194
  - 2. Utiliser un protocole standard195
  - 2.1 Client HTTP195
  - 2.2 Serveur HTTP196
  - 2.3 Proxy199
  - 2.4 Cookies200
  - 2.5 FTP et SFTP200
  - 2.6 SSH202
  - 2.7 POP et POPS204
  - 2.8 IMAP et IMAPS205
  - 2.9 SMTP et SMPTS206
  - 2.10 NNTP211
  - 2.11 IRC212
  - 3. Wake-on-LAN215
  - 3.1 Prérequis215
  - 3.2 Mise en oeuvre215
  - Chapitre 2.3
    Programmation web
  - 1. Services web217
  - 1.1 REST217
  - 1.2 SOAP218
  - 1.3 Pyro220
  - 2. Client web221
  - 3. Web scrapping225
  - Chapitre 2.4
    Programmation scientifique
  - 1. Calcul scientifique227
  - 1.1 Présentation227
  - 1.2 Python, une alternative libre et crédible227
  - 1.3 Vue d'ensemble de quelques bibliothèques228
  - 2. Tableaux multidimensionnels229
  - 2.1 Création229
  - 2.2 Déterminer la composition d'un tableau230
  - 2.3 Générateurs de tableaux231
  - 2.4 Opérations basiques232
  - 2.5 Opérateur crochet234
  - 3. Matrices236
  - 4. Génération de graphiques237
  - 4.1 Syntaxe MATLAB238
  - 4.2 Syntaxe objet239
  - 4.3 Mise en forme239
  - 4.4 Graphiques 3D244
  - 5. Introduction à Pandas247
  - 5.1 Présentation247
  - 5.2 Séries247
  - 5.3 Dataframes251
  - Partie 3
    Programmation concurrente
  - Chapitre 3.1
    Initiation à la programmation concurrente
  - 1. Notion de performance259
  - 1.1 Programmation bloquante259
  - 1.2 Utilisation de ressources CPU260
  - 1.3 Organisation de l'application261
  - 2. Terminologie262
  - 2.1 Processus262
  - 2.2 Fil d'exécution263
  - 2.3 Programmation non bloquante264
  - 2.4 Notion de GIL264
  - 3. Présentation des paradigmes265
  - 3.1 Programmation asynchrone265
  - 3.2 Programmation parallèle265
  - 3.3 Programmation distribuée266
  - 3.4 Programmation concurrente267
  - Chapitre 3.2
    Programmation asynchrone : initiation
  - 1. Utilité de la programmation asynchrone269
  - 2. Introduction à l'asynchrone270
  - 2.1 Notion de coroutine270
  - 2.2 Exécution d'une coroutine271
  - 2.3 Précisions sur le mot-clé await272
  - 2.4 Exécuter plusieurs coroutines en séries273
  - 2.5 Tâches asynchrones274
  - 2.6 Exécuter les tâches asynchrones de manière concurrente276
  - 2.7 Notion d'awaitable276
  - 2.8 Précisions sur asyncio.sleep276
  - 3. Éléments de grammaire277
  - 3.1 Gestionnaire de contexte asynchrone277
  - 3.2 Générateurs asynchrones278
  - 3.3 Compréhensions asynchrones278
  - 3.4 Itération asynchrone278
  - 4. Notion avancées278
  - 4.1 Introspection278
  - 4.2 Gestion du résultat ou de l'exception282
  - 4.3 Annuler une tâche283
  - 4.4 Se prémunir d'une annulation285
  - 4.5 Timeouts286
  - 4.6 Gestion globale fine de l'attente286
  - 4.7 Module contextvars289
  - 5. Boucle événementielle asynchrone292
  - 5.1 Gestion de la boucle291
  - 5.2 Débogage293
  - 5.3 Notion de future295
  - 5.4 Annulation297
  - 5.5 Gestion des exceptions298
  - 6. Utiliser la boucle événementielle302
  - 6.1 Utilisation des fonctions de retour (callbacks)302
  - 6.2 Planifier des appels à des fonctions classiques305
  - 6.3 Utiliser des signaux306
  - 6.4 Synchronisation309
  - 6.5 Communication entre coroutines313
  - 6.6 Exemple : lecture de l'entrée standard317
  - 6.7 Programmation parallèle et asynchrone318
  - 6.8 Exécuter du code bloquant318
  - 7. L'asynchrone suivant les versions de Python319
  - 7.1 Python 3.7319
  - 7.2 Python 3.6320
  - 7.3 Python 3.5320
  - 7.4 Python 3.4321
  - 7.5 Python 3.3 et inférieur321
  - 7.6 Python 2.7322
  - 8. Cas concret322
  - 8.1 Exemple de travail322
  - 9. Exemple retravaillé en utilisant des générateurs325
  - 9.1 Télécharger en asynchrone326
  - 9.2 Parser en asynchrone327
  - 9.3 Faire plusieurs traitements en asynchrone328
  - 9.4 Utiliser un exécuteur329
  - 9.5 Pour aller plus loin329
  - Chapitre 3.3
    Programmation asynchrone : avancée
  - 1. Transports et protocoles331
  - 1.1 Introduction331
  - 1.2 Transports331
  - 1.3 Protocoles335
  - 1.4 Mise en oeuvre336
  - 1.5 Exemple pour le protocole TCP338
  - 1.6 Exemple pour le protocole SSL346
  - 1.7 Exemple pour le protocole UDP349
  - 1.8 Traiter d'autres types de protocoles réseau352
  - 1.9 Exemple pour Subprocess353
  - 2. Flux359
  - 2.1 Introduction359
  - 2.2 Exemple avec le protocole TCP359
  - Chapitre 3.4
    Programmation asynchrone : alternatives
  - 1. Gevent363
  - 1.1 Introduction363
  - 1.2 DNS363
  - 1.3 Appels système364
  - 1.4 Programmation asynchrone365
  - 2. Twisted366
  - 2.1 Introduction366
  - 2.2 Client/serveur TCP366
  - 2.3 Serveur/client UDP368
  - 2.4 AMP369
  - 2.5 Autres protocoles372
  - 3. Trollius372
  - 4. HTTP asynchrone avec aiohttp374
  - 4.1 Côté serveur374
  - 4.2 Côté client376
  - Chapitre 3.5
    Programmation parallèle
  - 1. Utilisation d'un fil d'exécution377
  - 1.1 Gestion d'un fil d'exécution377
  - 1.1.1 Présentation377
  - 1.1.2 Création377
  - 1.2 Gestion de plusieurs fils d'exécution380
  - 1.2.1 Lancement et contrôle380
  - 1.2.2 Opportunité d'utiliser un fil d'exécution382
  - 1.3 Résolution des problématiques liées384
  - 1.3.1 Synchronisation384
  - 1.3.2 Synchronisation conditionnelle386
  - 1.3.3 Sémaphore388
  - 2. Utilisation de processus390
  - 2.1 Gestion d'un processus390
  - 2.1.1 Présentation390
  - 2.1.2 Création390
  - 2.2 Gestion de plusieurs processus393
  - 2.2.1 Synchronisation393
  - 2.2.2 Paralléliser un travail393
  - 2.3 Résolution des problématiques liées395
  - 2.3.1 Communication interprocessus395
  - 2.3.2 Partage de données entre processus397
  - 2.4 Opportunité d'utiliser les processus398
  - 2.5 Démon398
  - 3. Exécution asynchrone400
  - 3.1 Introduction400
  - 3.2 Présentation401
  - Chapitre 3.6
    Programmation distribuée
  - 1. Définitions407
  - 2. DiamètreMQ407
  - 2.1 Présentation générale407
  - 2.2 Pair409
  - 2.3 Client/serveur410
  - 2.4 Publish/subscribe411
  - 2.5 PUSH/PULL415
  - 2.6 Patron pipeline416
  - 3. AMQP avec RabbitMQ418
  - 3.1 Installation418
  - 3.2 Configuration418
  - 3.3 Introduction419
  - 3.4 Notions importantes421
  - 3.5 Publish/subscribe422
  - 3.6 Routage et sujets423
  - 4. Celery425
  - 4.1 Présentation425
  - 4.2 Dans quel cas utiliser Celery ?425
  - 4.3 Installation425
  - 4.4 Configuration426
  - 4.5 Utilisation427
  - 4.6 Monitorer429
  - 5. Crossbar429
  - 5.1 Présentation429
  - 5.2 WebSocket430
  - 5.3 Publish/subscribe436
  - Index439
Origine de la notice:
- Electre