1. Livres et vidéos
  2. Python 3 - Traitement de données et techniques de programmation

Python 3 Traitement de données et techniques de programmation

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce livre sur le langage Python 3 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.

Table des matières

  • Motifs de conception
    • 1. Définition
      • 1.1 Positionnement par rapport à la notion d’objet
      • 1.2 Organisation du chapitre
      • 1.3 Positionnement par rapport à d’autres concepts
    • 2. Motifs de création
      • 2.1 Singleton
      • 2.2 Fabrique
      • 2.3 Fabrique abstraite
      • 2.4 Monteur
      • 2.5 Prototype
    • 3. Motifs de structuration
      • 3.1 Adaptateur
      • 3.2 Pont
      • 3.3 Composite
      • 3.4 Décorateur
      • 3.5 Façade
      • 3.6 Poids-mouche
      • 3.7 Proxy
    • 4. Motifs de comportement
      • 4.1 Chaîne de responsabilité
      • 4.2 Commande
      • 4.3 Itérateur
      • 4.4 Mémento
      • 4.5 Visiteur
      • 4.6 Observateur
      • 4.7 Stratégie
      • 4.8 Fonction de rappel
    • 5. ZCA
      • 5.1 Rappels
      • 5.2 Adaptateur
      • 5.3 Utilitaire
      • 5.4 Fabrique
      • 5.5 Pour aller plus loin
  • XML
    • 1. XML et les technologies qui gravitent autour
      • 1.1 Définition de XML, terminologie associée
      • 1.2 Notion de schéma
      • 1.3 Avantages et inconvénients de XML
      • 1.4 Différentes manières de parcourir un fichier XML
      • 1.5 Modules Python dédiés au XML
    • 2. Valider un document XML
      • 2.1 Document XML
      • 2.2 Schéma DTD
      • 2.3 Schéma XSD
      • 2.4 Schéma RNG (RelaxNG)
      • 2.5 Schematron
    • 3. DOM
      • 3.1 Lecture
      • 3.2 Écriture
    • 4. SAX
      • 4.1 Support de SAX dans lxml
      • 4.2 API SAX Allégée
    • 5. XPath
    • 6. XSLT
    • 7. Cas spécifique des fichiers HTML
      • 7.1 Problématique
      • 7.2 Parser un fichier HTML à la façon DOM
      • 7.3 Parser un fichier HTML à la façon SAX
  • Génération de contenu
    • 1. PDF
      • 1.1 Présentation
        • 1.1.1 Format PDF
        • 1.1.2 Avantages
        • 1.1.3 Inconvénients
        • 1.1.4 Présentation de la bibliothèque libre
      • 1.2 Bas niveau
        • 1.2.1 Bibliothèque de données
        • 1.2.2 Canvas
      • 1.3 Haut niveau
        • 1.3.1 Styles
        • 1.3.2 Flux de données
        • 1.3.3 Création d’un visuel
        • 1.3.4 Template de page
        • 1.3.5 Page contenant plusieurs zones
    • 2. OpenDocument
      • 2.1 Présentation
      • 2.2 ezodf2
        • 2.2.1 Installation
        • 2.2.2 OpenDocument Texte
        • 2.2.3 OpenDocument Tableur
        • 2.2.4 Aller plus loin
      • 2.3 Alternatives
        • 2.3.1 lpod
        • 2.3.2 Génération à partir de templates
    • 3. Travailler avec des images
      • 3.1 Représentation informatique d’une image
      • 3.2 Présentation de Pillow
      • 3.3 Formats d’images matricielles
      • 3.4 Récupérer des informations d’une image
      • 3.5 Opérations d’ensemble sur une image
      • 3.6 Travailler avec les calques ou les pixels
  • Qualité
    • 1. Programmation dirigée par les tests
      • 1.1 Tests unitaires
        • 1.1.1 Principes
        • 1.1.2 Interprétation
        • 1.1.3 Couverture
        • 1.1.4 Outils
        • 1.1.5 Autres outils
      • 1.2 Tests de non-régression
        • 1.2.1 Actions de développement
        • 1.2.2 Gestion de la découverte d’une anomalie par une MOA
      • 1.3 Tests fonctionnels
      • 1.4 Tests de performance
      • 1.5 Tests syntaxiques
      • 1.6 Intégration continue
    • 2. Programmation dirigée par la documentation
      • 2.1 Documentation interne
        • 2.1.1 À destination des développeurs
        • 2.1.2 À destination des utilisateurs
      • 2.2 Documentation externe
        • 2.2.1 Présentation
        • 2.2.2 Démarrage rapide
        • 2.2.3 Résultat
    • 3. Optimisation
      • 3.1 Qualimétrie
      • 3.2 Outils de débogage
      • 3.3 Outils de profilage
      • 3.4 Règles d’optimisation
        • 3.4.1 Pourquoi optimiser ?
        • 3.4.2 Règles générales
        • 3.4.3 Profiler un algorithme
        • 3.4.4 Optimiser l'utilisation de la mémoire
  • Programmation système
    • 1. Présentation
      • 1.1 Définition
      • 1.2 Objectifs du chapitre
    • 2. Appréhender son système d’exploitation
      • 2.1 Avertissement
      • 2.2 Système d’exploitation
      • 2.3 Processus courant
      • 2.4 Utilisateurs et groupes
      • 2.5 Mots de passe et authentification
      • 2.6 Constantes pour le système de fichiers
      • 2.7 Gérer les chemins
      • 2.8 Utilitaires
        • 2.8.1 Comparer deux fichiers
        • 2.8.2 Utilitaire de sauvegarde
        • 2.8.3 Lire un fichier de configuration
        • 2.8.4 Pickle
      • 2.9 Compresser et décompresser un fichier
        • 2.9.1 Tarfile
        • 2.9.2 Gzip
        • 2.9.3 Bz2
        • 2.9.4 Zipfile
        • 2.9.5 Interface de haut niveau
    • 3. Gestion d’un fichier
      • 3.1 Changer les droits d’un fichier
      • 3.2 Changer de propriétaire ou de groupe
      • 3.3 Récupérer des informations sur un fichier
      • 3.4 Supprimer un fichier
    • 4. Alternatives simples à des commandes bash usuelles
      • 4.1 Répertoires
      • 4.2 Fichiers
      • 4.3 Module de haut niveau
      • 4.4 Recherche d’un fichier
    • 5. Exécuter des commandes externes
      • 5.1 Exécuter et afficher le résultat
      • 5.2 Exécuter et récupérer le résultat
      • 5.3 Pour Python 3.5 et supérieur
    • 6. IHM système
      • 6.1 Présentation
      • 6.2 Travailler avec des arguments
      • 6.3 Fermeture du programme
      • 6.4 Entrée standard
      • 6.5 Sortie standard
      • 6.6 Sortie d’erreur
      • 6.7 Taille du terminal
    • 7. Curses
      • 7.1 Présentation
      • 7.2 Gérer le démarrage et l'arrêt
      • 7.3 Affichage de texte
      • 7.4 Gestion des attributs
      • 7.5 Gestion des couleurs
      • 7.6 Gestion des événements
    • 8. Accès aux périphériques
      • 8.1 Introduction
      • 8.2 Voir les partitions
      • 8.3 Voir les clés USB
      • 8.4 Liste des informations disponibles
      • 8.5 Détecter le branchement d'une clé USB
      • 8.6 Communiquer via un port série
      • 8.7 Communiquer via un port USB
  • Programmation réseau
    • 1. Écrire un serveur et un client
      • 1.1 Utilisation d’une socket TCP
      • 1.2 Utilisation d’une socket UDP
      • 1.3 Création d’un serveur TCP
      • 1.4 Création d’un serveur UDP
      • 1.5 Un peu plus loin sur le sujet
    • 2. Utiliser un protocole standard
      • 2.1 Client HTTP
      • 2.2 Serveur HTTP
      • 2.3 Proxy
      • 2.4 Cookies
      • 2.5 FTP et SFTP
      • 2.6 SSH
      • 2.7 POP et POPS
      • 2.8 IMAP et IMAPS
      • 2.9 SMTP et SMPTS
      • 2.10 NNTP
      • 2.11 IRC
    • 3. Wake-on-LAN
      • 3.1 Prérequis
      • 3.2 Mise en œuvre
  • Programmation web
    • 1. Services web
      • 1.1 REST
      • 1.2 SOAP
      • 1.3 Pyro
    • 2. Client web
    • 3. Web scrapping
  • Programmation scientifique
    • 1. Calcul scientifique
      • 1.1 Présentation
      • 1.2 Python, une alternative libre et crédible
      • 1.3 Vue d'ensemble de quelques bibliothèques
    • 2. Tableaux multidimensionnels
      • 2.1 Création
      • 2.2 Déterminer la composition d'un tableau
      • 2.3 Générateurs de tableaux
      • 2.4 Opérations basiques
      • 2.5 Opérateur crochet
    • 3. Matrices
    • 4. Génération de graphiques
      • 4.1 Syntaxe MATLAB
      • 4.2 Syntaxe objet
      • 4.3 Mise en forme
      • 4.4 Graphiques 3D
    • 5. Introduction à Pandas
      • 5.1 Présentation
      • 5.2 Séries
      • 5.3 Dataframes
  • Initiation à la programmation concurrente
    • 1. Notion de performance
      • 1.1 Programmation bloquante
      • 1.2 Utilisation de ressources CPU
      • 1.3 Organisation de l’application
    • 2. Terminologie
      • 2.1 Processus
      • 2.2 Fil d’exécution
      • 2.3 Programmation non bloquante
      • 2.4 Notion de GIL
    • 3. Présentation des paradigmes
      • 3.1 Programmation asynchrone
      • 3.2 Programmation parallèle
      • 3.3 Programmation distribuée
      • 3.4 Programmation concurrente
  • Programmation asynchrone : initiation
    • 1. Utilité de la programmation asynchrone
    • 2. Introduction à l’asynchrone
      • 2.1 Notion de coroutine
      • 2.2 Exécution d’une coroutine
      • 2.3 Précisions sur le mot-clé await
      • 2.4 Exécuter plusieurs coroutines en séries
      • 2.5 Tâches asynchrones
      • 2.6 Exécuter les tâches asynchrones de manière concurrente
      • 2.7 Notion d’awaitable
      • 2.8 Précisions sur asyncio.sleep
    • 3. Éléments de grammaire
      • 3.1 Gestionnaire de contexte asynchrone
      • 3.2 Générateurs asynchrones
      • 3.3 Compréhensions asynchrones
      • 3.4 Itération asynchrone
    • 4. Notions avancées
      • 4.1 Introspection
      • 4.2 Gestion du résultat ou de l’exception
      • 4.3 Annuler une tâche
      • 4.4 Se prémunir d’une annulation
      • 4.5 Timeouts
      • 4.6 Gestion globale fine de l’attente
      • 4.7 Module contextvars
    • 5. Boucle événementielle asynchrone
      • 5.1 Gestion de la boucle
      • 5.2 Débogage
      • 5.3 Notion de future
      • 5.4 Annulation
      • 5.5 Gestion des exceptions
    • 6. Utiliser la boucle événementielle
      • 6.1 Utilisation des fonctions de retour (callbacks)
      • 6.2 Planifier des appels à des fonctions classiques
      • 6.3 Utiliser des signaux
      • 6.4 Synchronisation
      • 6.5 Communication entre coroutines
      • 6.6 Exemple : lecture de l’entrée standard
      • 6.7 Programmation parallèle et asynchrone
      • 6.8 Exécuter du code bloquant
    • 7. L’asynchrone suivant les versions de Python
      • 7.1 Python 3.7
      • 7.2 Python 3.6
      • 7.3 Python 3.5
      • 7.4 Python 3.4
      • 7.5 Python 3.3 et inférieur
      • 7.6 Python 2.7
    • 8. Cas concret
      • 8.1 Exemple de travail
    • 9. Exemple retravaillé en utilisant des générateurs
      • 9.1 Télécharger en asynchrone
      • 9.2 Parser en asynchrone
      • 9.3 Faire plusieurs traitements en asynchrone
      • 9.4 Utiliser un exécuteur
      • 9.5 Pour aller plus loin
  • Programmation asynchrone : avancée
    • 1. Transports et protocoles
      • 1.1 Introduction
      • 1.2 Transports
      • 1.3 Protocoles
      • 1.4 Mise en œuvre
      • 1.5 Exemple pour le protocole TCP
      • 1.6 Exemple pour le protocole SSL
      • 1.7 Exemple pour le protocole UDP
      • 1.8 Traiter d’autres types de protocoles réseau
      • 1.9 Exemple pour Subprocess
    • 2. Flux
      • 2.1 Introduction
      • 2.2 Exemple avec le protocole TCP
  • Programmation asynchrone : alternatives
    • 1. Gevent
      • 1.1 Introduction
      • 1.2 DNS
      • 1.3 Appels système
      • 1.4 Programmation asynchrone
    • 2. Twisted
      • 2.1 Introduction
      • 2.2 Client/serveur TCP
      • 2.3 Serveur/client UDP
      • 2.4 AMP
      • 2.5 Autres protocoles
    • 3. Trollius
    • 4. HTTP asynchrone avec aiohttp
      • 4.1 Côté serveur
      • 4.2 Côté client
  • Programmation parallèle
    • 1. Utilisation d’un fil d’exécution
      • 1.1 Gestion d’un fil d’exécution
        • 1.1.1 Présentation
        • 1.1.2 Création
      • 1.2 Gestion de plusieurs fils d’exécution
        • 1.2.1 Lancement et contrôle
        • 1.2.2 Opportunité d’utiliser un fil d’exécution
      • 1.3 Résolution des problématiques liées
        • 1.3.1 Synchronisation
        • 1.3.2 Synchronisation conditionnelle
        • 1.3.3 Sémaphore
    • 2. Utilisation de processus
      • 2.1 Gestion d’un processus
        • 2.1.1 Présentation
        • 2.1.2 Création
      • 2.2 Gestion de plusieurs processus
        • 2.2.1 Synchronisation
        • 2.2.2 Paralléliser un travail
      • 2.3 Résolution des problématiques liées
        • 2.3.1 Communication interprocessus
        • 2.3.2 Partage de données entre processus
      • 2.4 Opportunité d’utiliser les processus
      • 2.5 Démon
    • 3. Exécution asynchrone
      • 3.1 Introduction
      • 3.2 Présentation
  • Programmation distribuée
    • 1. Définitions
    • 2. ØMQ
      • 2.1 Présentation générale
      • 2.2 Pair
      • 2.3 Client/serveur
      • 2.4 Publish/subscribe
      • 2.5 Push/pull
      • 2.6 Patron pipeline
    • 3. AMQP avec RabbitMQ
      • 3.1 Installation
      • 3.2 Configuration
      • 3.3 Introduction
      • 3.4 Notions importantes
      • 3.5 Publish/subscribe
      • 3.6 Routage et sujets
    • 4. Celery
      • 4.1 Présentation
      • 4.2 Dans quel cas utiliser Celery ?
      • 4.3 Installation
      • 4.4 Configuration
      • 4.5 Utilisation
      • 4.6 Monitorer
    • 5. Crossbar
      • 5.1 Présentation
      • 5.2 WebSocket
      • 5.3 Publish/subscribe
    • Index

Auteur

Sébastien CHAZALLETEn savoir plus

Expert technique Python/Django et Web Backend/Frontend, Sébastien Chazallet intervient en tant qu'indépendant sur de longues missions de développement, d'audit, d'expertise et de formation (www.formation-python.com, www.inspyration.fr). Ses réalisations portent sur des développements autour de Python sur des projets de grande envergure, essentiellement des applications intranet sur mesure avec Django, mais également sur des applications de bureau, des scripts système, la création de sites web ou de e-commerce.

Caractéristiques

  • Niveau Confirmé à Expert
  • Nombre de pages 448 pages
  • Parution janvier 2020
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-02292-0
    • EAN : 9782409022920
    • Ref. ENI : EI3PYT
  • Niveau Confirmé à Expert
  • Parution janvier 2020
    • HTML
    • ISBN : 978-2-409-02293-7
    • EAN : 9782409022937
    • Ref. ENI : LNEI3PYT

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (36,3 Mo)