Ce support sur les fondamentaux du langage Python s’adresse à tout professionnel de l’informatique, ingénieur, étudiant, enseignant ou même autodidacte qui souhaite maîtriser ce langage très abouti. Il couvre un périmètre relativement large, détaille tout le cœur du langage et du traitement de données et ouvre des perspectives importantes sur tout ce que Python permet de faire (de la création d'un site web au développement de jeux en passant par la conception d'une interface graphique).

La première partie du livre détaille les atouts de Python pour répondre aux besoins des entreprises quel que soit le domaine informatique concerné. La seconde partie porte sur les fondamentaux du langage : les notions sont présentées progressivement avec des exemples de code qui illustrent chaque propos. L’auteur a souhaité que le lecteur atteigne une autonomie réelle dans son apprentissage, avec pour chaque notion présentée deux objectifs distincts : permettre à celui qui ne connaît pas la notion de se l’approprier correctement, notamment en respectant son rôle, et permettre à celui qui la connaît de trouver des angles d’attaques originaux pour aller le plus loin possible dans son exploitation. Cette première partie, qui porte donc sur le cœur du langage, est résolument tournée vers la branche 3 de Python. Néanmoins, lorsqu’elles existent, l’auteur présente les différences avec la branche antérieure de Python.

La troisième partie permet de voir comment utiliser Python pour résoudre des problématiques métiers et donc, comment utiliser tout ce qu’il y a autour de Python (protocoles, serveurs, images, …). Dans cette partie, le fil conducteur est la fonctionnalité et non pas le module ; chaque chapitre se concentre sur la manière d’exploiter une fonctionnalité par l’utilisation d’un ou de plusieurs modules et présente une méthodologie, mais n’est pas centré sur une description anatomique des modules eux-mêmes.

Enfin, la dernière partie de l’ouvrage est un vaste tutoriel qui permet de mettre en pratique, dans un cadre professionnel, tout ce qui a été vu précédemment en créant une application qui couvre tous les domaines courants du développement (Données, Web, Interface graphique …) et ainsi de présenter des solutions efficaces de développements utilisant Python.

Le code source de cette dernière partie 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.


Les chapitres du livre :
Avant-propos - Python dans le paysage informatique - Présentation de Python - Pourquoi choisir Python - Installer son environnement de développement - Algorithmique de base – Déclarations - Modèle objet - Types de données et algorithmes appliqués - Motifs de conception - Manipulation de données - Génération de contenu - Programmation parallèle - Programmation système et réseau - Bonnes pratiques - Créer une application web en 30 minutes - Créer une application console en 10 minutes - Créer une application graphique en 20 minutes - Créer un jeu en 30 minutes avec PyGame - Introduction à Grok en 10 minutes – Annexes

Téléchargements

• Des fichiers complémentaires (36,4 Mo)
• Webographie

Avant-propos

1. 1. Contenu de l’ouvrage
2. 2. À destination des enseignants et élèves
3. 3. À destination des chercheurs ou doctorants
4. 4. À destination de ceux qui viennent d’un autre langage

Python dans le paysage informatique

1. 1. Petite histoire des langages informatiques
   1. 1.1 Informatique théorique
   2. 1.2 Chronologie de l’informatique
      1. 1.2.1 Évolutions des problématiques liées à l’informatique
      2. 1.2.2 Chronologie des langages informatiques
   3. 1.3 Histoire de Python
      1. 1.3.1 La genèse
      2. 1.3.2 Extension du périmètre fonctionnel
      3. 1.3.3 Évolution de la licence
      4. 1.3.4 Avenir
2. 2. Typologie des langages de programmation
   1. 2.1 Paradigmes
      1. 2.1.1 Définition
      2. 2.1.2 Paradigme impératif et dérivés
      3. 2.1.3 Paradigme objet et dérivés
      4. 2.1.4 Programmation orientée aspect
      5. 2.1.5 Paradigme fonctionnel
      6. 2.1.6 Paradigme logique
      7. 2.1.7 Programmation concurrente
      8. 2.1.8 Synthèse
   2. 2.2 Interopérabilité
   3. 2.3 Niveau de programmation
      1. 2.3.1 Machine
      2. 2.3.2 Bas niveau
      3. 2.3.3 Haut niveau
   4. 2.4 Typage
      1. 2.4.1 Faible vs fort
      2. 2.4.2 Statique vs dynamique
   5. 2.5 Grammaire
      1. 2.5.1 Langages formels
      2. 2.5.2 Syntaxe
3. 3. Situer Python dans ce paysage
   1. 3.1 Typologie de Python
      1. 3.1.1 Grammaire et syntaxe
      2. 3.1.2 Typage
      3. 3.1.3 Niveau de programmation
      4. 3.1.4 Paradigmes supportés
   2. 3.2 Positionnement stratégique du langage Python
      1. 3.2.1 Segments de marchés
      2. 3.2.2 Niveau de complexité
      3. 3.2.3 Forces du langage
      4. 3.2.4 Points faibles
   3. 3.3 Intégration avec d’autres langages
      1. 3.3.1 Extensions C
      2. 3.3.2 Intégration de programmes écrits en C
      3. 3.3.3 Intégration de programmes Python dans du C
      4. 3.3.4 Intégration de programmes écrits en Java
      5. 3.3.5 Intégration de programmes Python dans Java
      6. 3.3.6 Autres intégrations
   4. 3.4 Intégration de données
      1. 3.4.1 SGBD
      2. 3.4.2 LDAP
      3. 3.4.3 XML
      4. 3.4.4 Système de fichiers et systèmes d’exploitation
      5. 3.4.5 Flux réseau
   5. 3.5 Réalisation d’applications Web
      1. 3.5.1 Travailler avec des flux HTML
      2. 3.5.2 Travailler avec le protocole HTTP
   6. 3.6 Réalisation d’interfaces graphiques
      1. 3.6.1 Ponts vers C ou autres bibliothèques de référence
      2. 3.6.2 Utilisation de bibliothèques Java
   7. 3.7 Piles incluses

Présentation de Python

1. 1. Philosophie
   1. 1.1 Python en quelques lignes
      1. 1.1.1 D’où vient le nom « Python » ?
      2. 1.1.2 Présentation technique
      3. 1.1.3 Présentation conceptuelle
   2. 1.2 Comparaison avec d’autres langages
      1. 1.2.1 Shell
      2. 1.2.2 Perl
      3. 1.2.3 C, C++
      4. 1.2.4 Java
      5. 1.2.5 PHP
   3. 1.3 Grands principes
      1. 1.3.1 Le zen de Python
      2. 1.3.2 Le développeur n’est pas stupide
      3. 1.3.3 Documentation
      4. 1.3.4 Python est livré piles incluses
      5. 1.3.5 Duck Typing
      6. 1.3.6 Notion de code pythonique
2. 2. Gouvernance
   1. 2.1 Développement
      1. 2.1.1 Branches
      2. 2.1.2 Communauté
   2. 2.2 Mode de gouvernance
      1. 2.2.1 Créateur du langage
      2. 2.2.2 PEP
      3. 2.2.3 Prise de décisions
3. 3. Que contient Python ?
   1. 3.1 Une grammaire et une syntaxe
   2. 3.2 Une bibliothèque standard
   3. 3.3 Des bibliothèques tierces
   4. 3.4 Des frameworks
4. 4. Phases d’exécution d’un programme Python
   1. 4.1 Chargement de la machine virtuelle
   2. 4.2 Compilation
   3. 4.3 Interprétation
   4. 4.4 Problématique de la compilation à la volée

Pourquoi choisir Python

1. 1. Qualités du langage
   1. 1.1 Couverture fonctionnelle
   2. 1.2 Ticket d’entrée
   3. 1.3 Garanties
2. 2. Diffusion
   1. 2.1 Entreprises
   2. 2.2 Le monde de la recherche
   3. 2.3 Le monde de l’éducation
   4. 2.4 Communauté
3. 3. Références
   1. 3.1 Poids lourds de l’industrie informatique
      1. 3.1.1 Google
      2. 3.1.2 Mozilla
      3. 3.1.3 Microsoft
      4. 3.1.4 Canonical
      5. 3.1.5 Cisco
   2. 3.2 Entreprises innovantes
      1. 3.2.1 Services de stockage en ligne
      2. 3.2.2 Informatique dématérialisée
      3. 3.2.3 Forge
      4. 3.2.4 Réseaux sociaux
   3. 3.3 Éditeurs de contenus
      1. 3.3.1 Disney Animation Studio
      2. 3.3.2 Youtube
      3. 3.3.3 Box ADSL
      4. 3.3.4 Spotify
   4. 3.4 Éditeurs de logiciels
4. 4. Retours d’expérience
   1. 4.1 Ressentis
   2. 4.2 Développement dans un contexte hétérogène
   3. 4.3 Développement rapide
   4. 4.4 Vendre des développements Python
   5. 4.5 Naviguer dans l’inconnu

Installer son environnement de développement

1. 1. Installer Python
   1. 1.1 Windows
   2. 1.2 Mac OS
   3. 1.3 UNIX / Linux
   4. 1.4 Compilation
2. 2. Installer des bibliothèques externes
   1. 2.1 Installateur ou gestionnaire de paquets
   2. 2.2 Setuptools et PIP
3. 3. Installer un IDE
   1. 3.1 Console et outils associés
   2. 3.2 Eclipse + pydev
   3. 3.3 Eric
   4. 3.4 Autres solutions
4. 4. Implémentations de Python
   1. 4.1 CPython
   2. 4.2 PyPy
   3. 4.3 Jython
   4. 4.4 IronPython
   5. 4.5 StacklessPython
   6. 4.6 Environnement hétérogène
5. 5. Utilisation de la console
   1. 5.1 Console standard
   2. 5.2 iPython
6. 6. Distribuer ses propres applications
   1. 6.1 Utilitaire de distribution
   2. 6.2 Création de paquets distribuables
   3. 6.3 Distribution binaire pour Windows
   4. 6.4 Distribution binaire pour Mac
   5. 6.5 Distribution binaire toute plateforme
   6. 6.6 Distribution spécifique à un environnement

Algorithmique de base

1. 1. Délimiteurs
   1. 1.1 Ligne de code
   2. 1.2 Opérateurs
   3. 1.3 Symboles
   4. 1.4 Mots-clés
   5. 1.5 Indentation
   6. 1.6 Utilisation du caractère souligné
   7. 1.7 PEP-8
   8. 1.8 PEP-7
   9. 1.9 PEP-257
2. 2. Instructions
   1. 2.1 Définitions
      1. 2.1.1 Fonction
      2. 2.1.2 Classe
      3. 2.1.3 Instruction vide
      4. 2.1.4 Suppression
      5. 2.1.5 Renvoyer le résultat de la fonction
   2. 2.2 Instructions conditionnelles
      1. 2.2.1 Définition
      2. 2.2.2 Condition
      3. 2.2.3 Instruction not
      4. 2.2.4 Instruction if
      5. 2.2.5 Instruction elif
      6. 2.2.6 Instruction else
      7. 2.2.7 Instruction switch
      8. 2.2.8 Interruptions
      9. 2.2.9 Approfondissement des conditions
      10. 2.2.10 Performances
   3. 2.3 Itérations
      1. 2.3.1 Instruction for
      2. 2.3.2 Instruction while
      3. 2.3.3 Instruction break
      4. 2.3.4 Instruction return
      5. 2.3.5 Instruction continue
      6. 2.3.6 Instruction else
      7. 2.3.7 Générateurs
   4. 2.4 Constructions fonctionnelles
      1. 2.4.1 Générateurs
      2. 2.4.2 Compréhensions de listes
      3. 2.4.3 Compréhensions d’ensembles
      4. 2.4.4 Compréhensions de dictionnaires
   5. 2.5 Gestion des exceptions
      1. 2.5.1 Présentation rapide des exceptions
      2. 2.5.2 Lever une exception
      3. 2.5.3 Capturer une exception
      4. 2.5.4 Effectuer un traitement de l’exception
      5. 2.5.5 Gérer la sortie de la boucle de capture
      6. 2.5.6 Gérer le non-déclenchement d’exceptions
      7. 2.5.7 Prise et libération de ressources
      8. 2.5.8 Assertions
   6. 2.6 Divers
      1. 2.6.1 Gérer des imports
      2. 2.6.2 Traverser les espaces de nommage
      3. 2.6.3 Fonctions lambda
      4. 2.6.4 Instructions eval et exec

Déclarations

1. 1. Variable
   1. 1.1 Qu’est-ce qu’une variable ?
      1. 1.1.1 Contenu
      2. 1.1.2 Contenant
      3. 1.1.3 Modes de modification d’une variable
   2. 1.2 Typage dynamique
      1. 1.2.1 Affectation
      2. 1.2.2 Primitive type et nature du type
      3. 1.2.3 Caractéristiques du typage Python
   3. 1.3 Visibilité
      1. 1.3.1 Espace global
      2. 1.3.2 Notion de bloc
2. 2. Fonction
   1. 2.1 Déclaration
   2. 2.2 Paramètres
      1. 2.2.1 Signature d’une fonction
      2. 2.2.2 Notion d’argument ou de paramètre
      3. 2.2.3 Valeur par défaut
      4. 2.2.4 Paramètres nommés
      5. 2.2.5 Déclaration de paramètres extensibles
      6. 2.2.6 Passage de paramètres étoilés
      7. 2.2.7 Signature universelle
      8. 2.2.8 Obliger un paramètre à être nommé (keyword-only)
      9. 2.2.9 Annotations
3. 3. Classe
   1. 3.1 Déclaration
      1. 3.1.1 Signature
      2. 3.1.2 Attribut
      3. 3.1.3 Méthode
      4. 3.1.4 Bloc local
   2. 3.2 Instanciation
      1. 3.2.1 Syntaxe
      2. 3.2.2 Relation entre l’instance et la classe
4. 4. Module
   1. 4.1 Déclaration
   2. 4.2 Instructions spécifiques
   3. 4.3 Comment appréhender le contenu d’un module ?

Modèle objet

1. 1. Tout est objet
   1. 1.1 Principes
      1. 1.1.1 Quel sens donner à « objet » ?
      2. 1.1.2 Adaptation du modèle objet dans Python
   2. 1.2 Classes
      1. 1.2.1 Introduction
      2. 1.2.2 Déclaration impérative d’une classe
      3. 1.2.3 Instance
      4. 1.2.4 Objet courant
      5. 1.2.5 Déclaration par prototype d’une classe
   3. 1.3 Méthodes
      1. 1.3.1 Déclaration
      2. 1.3.2 Appel de méthode
      3. 1.3.3 Méthodes et attributs spéciaux
   4. 1.4 Héritage
      1. 1.4.1 Polymorphisme par sous-typage
      2. 1.4.2 Surcharge de méthode
      3. 1.4.3 Surcharge des opérateurs
      4. 1.4.4 Polymorphisme paramétrique
      5. 1.4.5 Héritage multiple
2. 2. Autres outils de la programmation objet
   1. 2.1 Principes
   2. 2.2 Interfaces
   3. 2.3 Attributs
   4. 2.4 Propriétés
   5. 2.5 Emplacements
   6. 2.6 Métaclasses
   7. 2.7 Classes abstraites
   8. 2.8 La Zope Component Architecture
      1. 2.8.1 Présentation
      2. 2.8.2 Installation
      3. 2.8.3 Définir une interface et un composant
      4. 2.8.4 Autres fonctionnalités
      5. 2.8.5 Avantages de la ZCA
3. 3. Fonctions spéciales et primitives associées
   1. 3.1 Personnalisation
      1. 3.1.1 Classes
      2. 3.1.2 Singleton
      3. 3.1.3 Instances
      4. 3.1.4 Comparaison
      5. 3.1.5 Évaluation booléenne
      6. 3.1.6 Relations d’héritage ou de classe à instance
   2. 3.2 Classes particulières
      1. 3.2.1 Itérateurs
      2. 3.2.2 Conteneurs
      3. 3.2.3 Instances assimilables à des fonctions
      4. 3.2.4 Ressources à protéger
      5. 3.2.5 Types

Types de données et algorithmes appliqués

1. 1. Nombres
   1. 1.1 Types
      1. 1.1.1 Entiers
      2. 1.1.2 Réels
      3. 1.1.3 Socle commun aux nombres entiers et réels
      4. 1.1.4 Méthodes dédiées aux nombres entiers
      5. 1.1.5 Méthodes dédiées aux nombres réels
      6. 1.1.6 Complexes
   2. 1.2 La console Python, la calculatrice par excellence
      1. 1.2.1 Opérateurs mathématiques binaires
      2. 1.2.2 Opérateurs binaires particuliers
      3. 1.2.3 Opérateurs mathématiques unaires
      4. 1.2.4 Arrondis
      5. 1.2.5 Opérateurs de comparaison
      6. 1.2.6 Opérations mathématiques n-aires
      7. 1.2.7 Fonctions mathématiques usuelles
   3. 1.3 Représentations d'un nombre
      1. 1.3.1 Représentation décimale
      2. 1.3.2 Représentation par un exposant
      3. 1.3.3 Représentation par une fraction
      4. 1.3.4 Représentation hexadécimale
      5. 1.3.5 Représentation octale
      6. 1.3.6 Représentation binaire
      7. 1.3.7 Opérations binaires
      8. 1.3.8 Longueur de la représentation mémoire d'un entier
   4. 1.4 Conversions
      1. 1.4.1 Conversion entre entiers et réels
      2. 1.4.2 Conversion entre réels et complexes
      3. 1.4.3 Conversion vers un booléen
   5. 1.5 Travailler avec des variables
      1. 1.5.1 Un nombre est non mutable
      2. 1.5.2 Modifier la valeur d'une variable
      3. 1.5.3 Opérateurs d'incrémentation
   6. 1.6 Calcul scientifique
      1. 1.6.1 Le calcul scientifique, pour quoi faire ?
      2. 1.6.2 Python, une alternative libre et crédible
      3. 1.6.3 Quelques bibliothèques
      4. 1.6.4 Quelques projets
2. 2. Séquences
   1. 2.1 Présentation des différents types de séquences
      1. 2.1.1 Généralités
      2. 2.1.2 Les listes
      3. 2.1.3 Les n-uplets
      4. 2.1.4 Conversion entre listes et n-uplets
      5. 2.1.5 Socle commun entre liste et n-uplet
      6. 2.1.6 Notion d’itérateur
   2. 2.2 Utilisation des indices et des tranches
      1. 2.2.1 Définition de l’indice d’un objet et des occurrences
      2. 2.2.2 Utiliser l’indice pour adresser la séquence
      3. 2.2.3 Retrouver les occurrences d’un objet et leurs indices
      4. 2.2.4 Taille d’une liste, comptage d’occurrences
      5. 2.2.5 Utiliser l’indice pour modifier ou supprimer
      6. 2.2.6 Itération simple
      7. 2.2.7 Présentation de la notion de tranches (slices)
      8. 2.2.8 Cas particulier de la branche 2.x de Python
      9. 2.2.9 Utilisation basique des tranches
      10. 2.2.10 Utilisation avancée des tranches
   3. 2.3 Utilisation des opérateurs
      1. 2.3.1 Opérateur +
      2. 2.3.2 Opérateur *
      3. 2.3.3 Opérateur +=
      4. 2.3.4 Opérateur *=
      5. 2.3.5 Opérateur in
      6. 2.3.6 Opérateurs de comparaison
   4. 2.4 Méthodes de modifications
      1. 2.4.1 Ajouter des éléments dans une liste et un n-uplet
      2. 2.4.2 Supprimer un objet d’une liste et d’un n-uplet
      3. 2.4.3 Solutions de contournement pour la modification de n-uplets
      4. 2.4.4 Renverser une liste ou un tuple
      5. 2.4.5 Trier une liste
   5. 2.5 Utilisation avancée des listes
      1. 2.5.1 Opérations d'ensemble
      2. 2.5.2 Pivoter une séquence
      3. 2.5.3 Itérer correctement
      4. 2.5.4 Programmation fonctionnelle
      5. 2.5.5 Compréhensions de listes
      6. 2.5.6 Itérations avancées
      7. 2.5.7 Combinatoire
   6. 2.6 Adapter les listes à des besoins spécifiques
      1. 2.6.1 Liste d'entiers
      2. 2.6.2 Présentation du type array
      3. 2.6.3 Utiliser une liste comme pile
      4. 2.6.4 Utiliser une liste comme file d'attente
      5. 2.6.5 Utiliser des listes pour représenter des matrices
      6. 2.6.6 Liste sans doublons
3. 3. Ensembles
   1. 3.1 Présentation
      1. 3.1.1 Définition d’un ensemble
      2. 3.1.2 Différences entre set et frozenset
      3. 3.1.3 Utilisation pour dédoublonner des listes
      4. 3.1.4 Rajouter une relation d’ordre
   2. 3.2 Opérations ensemblistes
      1. 3.2.1 Opérateurs pour un ensemble à partir de deux autres
      2. 3.2.2 Opérateurs pour modifier un ensemble à partir d’un autre
      3. 3.2.3 Méthodes équivalentes à la création ou modification ensembliste
      4. 3.2.4 Méthodes de comparaison des ensembles
      5. 3.2.5 Exemples non classiques d’utilisation
   3. 3.3 Méthodes de modification d’un ensemble
      1. 3.3.1 Ajouter un élément
      2. 3.3.2 Supprimer un élément
      3. 3.3.3 Vider un ensemble
      4. 3.3.4 Dupliquer un élément
      5. 3.3.5 Sortir une valeur d’un ensemble
      6. 3.3.6 Utiliser un ensemble comme un recycleur d’objets
      7. 3.3.7 Algorithmique avancée : résolution du problème des n-dames
4. 4. Chaînes de caractères
   1. 4.1 Présentation
      1. 4.1.1 Définition
      2. 4.1.2 Vocabulaire
      3. 4.1.3 Spécificités de la branche 2.x
      4. 4.1.4 Changements apportés par la branche 3.x
      5. 4.1.5 Chaîne de caractères en tant que séquence de caractères
      6. 4.1.6 Caractères
      7. 4.1.7 Opérateurs de comparaison
   2. 4.2 Formatage de chaînes de caractères
      1. 4.2.1 Opérateur modulo
      2. 4.2.2 Méthodes de formatage sur l’ensemble de la chaîne
      3. 4.2.3 Nouvelle méthode de formatage des variablesdans une chaîne
   3. 4.3 Opérations d'ensemble
      1. 4.3.1 Séquençage de chaînes
      2. 4.3.2 Opérations sur la casse
      3. 4.3.3 Recherche sur une chaîne de caractères
      4. 4.3.4 Informations sur les caractères
   4. 4.4 Problématiques relatives à l'encodage
      1. 4.4.1 Encodage par défaut
      2. 4.4.2 Encodage du système
      3. 4.4.3 L'unicode, référence absolue
      4. 4.4.4 Autres encodages
      5. 4.4.5 Ponts entre l'unicode et le reste du monde
      6. 4.4.6 Revenir vers l'unicode
   5. 4.5 Manipulations de bas niveau avancées
      1. 4.5.1 Opérations de comptage
      2. 4.5.2 Une chaîne de caractères vue comme une liste
      3. 4.5.3 Une chaîne de caractères vue comme un ensemble de caractères
   6. 4.6 Représentation mémoire
      1. 4.6.1 Présentation du type bytes
      2. 4.6.2 Lien avec les chaînes de caractères
      3. 4.6.3 Présentation du type bytearray
      4. 4.6.4 Gestion d’un jeu de caractères
5. 5. Dictionnaires
   1. 5.1 Présentation
      1. 5.1.1 Définition
      2. 5.1.2 Évolutions et différences entre les branches 2.x et 3.x
      3. 5.1.3 Vues de dictionnaires
      4. 5.1.4 Instanciation
      5. 5.1.5 Compréhension de dictionnaire
   2. 5.2 Manipuler un dictionnaire
      1. 5.2.1 Récupérer une valeur d’un dictionnaire
      2. 5.2.2 Modifier les valeurs d’un dictionnaire
      3. 5.2.3 Supprimer une entrée d’un dictionnaire
      4. 5.2.4 Dupliquer un dictionnaire
      5. 5.2.5 Utiliser le dictionnaire comme agrégateur de données
      6. 5.2.6 Méthodes d’itération
   3. 5.3 Utilisation avancée des dictionnaires
      1. 5.3.1 Rajouter une relation d'ordre
      2. 5.3.2 Algorithmique classique
      3. 5.3.3 Adapter les dictionnaires à des besoins spécifiques
      4. 5.3.4 Représentation universelle de données
6. 6. Booléens
   1. 6.1 Le type booléen
      1. 6.1.1 Classe bool
      2. 6.1.2 Les deux objets True et False
      3. 6.1.3 Différence entre l’opérateur d’égalité et d'identité
   2. 6.2 Évaluation booléenne
      1. 6.2.1 Méthode générique
      2. 6.2.2 Objets classiques
7. 7. Données temporelles
   1. 7.1 Gérer une date calendaire
      1. 7.1.1 Notion de date calendaire
      2. 7.1.2 Travailler sur une date
      3. 7.1.3 Considérations astronomiques
      4. 7.1.4 Considérations historiques
      5. 7.1.5 Considérations techniques
      6. 7.1.6 Représentation textuelle
   2. 7.2 Gérer un horaire ou un moment d’une journée
      1. 7.2.1 Notion d’instant
      2. 7.2.2 Notion de fuseau horaire
      3. 7.2.3 Représentation textuelle
   3. 7.3 Gérer un instant absolu
      1. 7.3.1 Notion d’instant absolu
      2. 7.3.2 Rapport avec les notions précédentes
      3. 7.3.3 Représentation textuelle
      4. 7.3.4 Gestion des fuseaux horaires
      5. 7.3.5 Créer une date à partir d’une représentation textuelle
   4. 7.4 Gérer une différence entre deux dates ou instants
      1. 7.4.1 Notion de différence et de résolution
      2. 7.4.2 Considérations techniques
      3. 7.4.3 Utilisation avec des dates calendaires
      4. 7.4.4 Utilisation avec des horaires
      5. 7.4.5 Utilisation avec des dates absolues
      6. 7.4.6 La seconde comme unité de base
   5. 7.5 Spécificités des fuseaux horaires
   6. 7.6 Problématiques de bas niveau
      1. 7.6.1 Timestamp et struct_time
      2. 7.6.2 Mesures de performances
   7. 7.7 Utilisation du calendrier
      1. 7.7.1 Présentation du module calendar
      2. 7.7.2 Fonctions essentielles du calendrier

Motifs de conception

1. 1. Définition
   1. 1.1 Positionnement par rapport à la notion d’objet
   2. 1.2 Organisation du chapitre
   3. 1.3 Positionnement par rapport à d’autres concepts
2. 2. Création
   1. 2.1 Singleton
   2. 2.2 Fabrique
      1. 2.2.1 Présentation de la problématique
      2. 2.2.2 Solutions
      3. 2.2.3 Conséquences
   3. 2.3 Fabrique abstraite
      1. 2.3.1 Présentation de la problématique
      2. 2.3.2 Solution
   4. 2.4 Monteur
      1. 2.4.1 Présentation de la problématique
      2. 2.4.2 Solution
      3. 2.4.3 Conséquences
   5. 2.5 Prototype
      1. 2.5.1 Présentation de la problématique
      2. 2.5.2 Solution
      3. 2.5.3 Conséquences
3. 3. Structuration
   1. 3.1 Adaptateur
      1. 3.1.1 Présentation de la problématique
      2. 3.1.2 Solution
      3. 3.1.3 Conséquences
   2. 3.2 Pont
      1. 3.2.1 Présentation de la problématique
      2. 3.2.2 Solution
      3. 3.2.3 Conséquences
   3. 3.3 Composite
      1. 3.3.1 Présentation de la problématique
      2. 3.3.2 Solution
      3. 3.3.3 Conséquences
   4. 3.4 Décorateur
      1. 3.4.1 Présentation de la problématique
      2. 3.4.2 Solution
      3. 3.4.3 Conséquences
   5. 3.5 Façade
      1. 3.5.1 Présentation de la problématique
      2. 3.5.2 Solution
      3. 3.5.3 Conséquences
   6. 3.6 Poids-mouche
      1. 3.6.1 Présentation de la problématique
      2. 3.6.2 Solution
      3. 3.6.3 Conséquences
   7. 3.7 Proxy
      1. 3.7.1 Présentation de la problématique
      2. 3.7.2 Solution
      3. 3.7.3 Conséquences
4. 4. Comportement
   1. 4.1 Chaîne de responsabilité
      1. 4.1.1 Présentation de la problématique
      2. 4.1.2 Solution
      3. 4.1.3 Conséquences
   2. 4.2 Commande
      1. 4.2.1 Présentation de la problématique
      2. 4.2.2 Solution
      3. 4.2.3 Conséquences
   3. 4.3 Itérateur
      1. 4.3.1 Présentation de la problématique
      2. 4.3.2 Solution
      3. 4.3.3 Conséquences
   4. 4.4 Mémento
      1. 4.4.1 Présentation de la problématique
      2. 4.4.2 Solution
      3. 4.4.3 Conséquences
   5. 4.5 Visiteur
      1. 4.5.1 Présentation de la problématique
      2. 4.5.2 Solution
      3. 4.5.3 Conséquences
   6. 4.6 Observateur
      1. 4.6.1 Présentation de la problématique
      2. 4.6.2 Solution
      3. 4.6.3 Conséquences
   7. 4.7 Stratégie
      1. 4.7.1 Présentation de la problématique
      2. 4.7.2 Solution
      3. 4.7.3 Conséquences
   8. 4.8 Fonction de rappel
      1. 4.8.1 Présentation de la problématique
      2. 4.8.2 Solution
      3. 4.8.3 Conséquences
5. 5. ZCA
   1. 5.1 Rappels
   2. 5.2 Adaptateur
      1. 5.2.1 Déclaration
      2. 5.2.2 Utilisation
   3. 5.3 Utilitaire
      1. 5.3.1 Déclaration
      2. 5.3.2 Utilisation
   4. 5.4 Fabrique
      1. 5.4.1 Déclaration
      2. 5.4.2 Utilisation
   5. 5.5 Pour aller plus loin

Manipulation de données

1. 1. Bases de données
   1. 1.1 Présentation
   2. 1.2 Accès à une base de données relationnelle
      1. 1.2.1 Point d’entrée
      2. 1.2.2 MySQL
      3. 1.2.3 PostgreSQL
      4. 1.2.4 SQLite
      5. 1.2.5 Oracle
   3. 1.3 Utilisation d’un ORM
      1. 1.3.1 Qu’est-ce qu’un ORM ?
      2. 1.3.2 ORM proposés par Python
      3. 1.3.3 SQLAlchemy
   4. 1.4 Autres bases de données
      1. 1.4.1 CSV
      2. 1.4.2 NoSQL
      3. 1.4.3 Base de données orientée objet : ZODB
      4. 1.4.4 Base de données de type clé-valeur : REDIS, Cassandra
      5. 1.4.5 Bases de données orientées documents : CouchDB et MongoDB
      6. 1.4.6 Bases de données natives XML : XSDB, BaseX
2. 2. LDAP
   1. 2.1 Présentation
      1. 2.1.1 Protocole
      2. 2.1.2 Serveurs
      3. 2.1.3 Terminologie
   2. 2.2 Se connecter et s’authentifier
   3. 2.3 Mode synchrone, mode asynchrone
   4. 2.4 Rechercher des données
3. 3. XML
   1. 3.1 XML et les technologies qui gravitent autour
      1. 3.1.1 Définition de XML, terminologie associée
      2. 3.1.2 Notion de schéma
      3. 3.1.3 Avantages et inconvénients de XML
      4. 3.1.4 Différentes manières de parcourir un fichier XML
      5. 3.1.5 Modules Python dédiés au XML
   2. 3.2 Valider un document XML
      1. 3.2.1 Document XML
      2. 3.2.2 Schéma DTD
      3. 3.2.3 Schéma XSD
      4. 3.2.4 Schéma RNG (RelaxNG)
      5. 3.2.5 Schematron
   3. 3.3 DOM
      1. 3.3.1 Lecture
      2. 3.3.2 Écriture
   4. 3.4 SAX
      1. 3.4.1 Support de SAX dans lxml
      2. 3.4.2 API SAX Allégée
   5. 3.5 XPath
   6. 3.6 XSLT
   7. 3.7 Cas spécifiques des fichiers HTML
      1. 3.7.1 Problématique
      2. 3.7.2 Parser un fichier HTML à la façon DOM
      3. 3.7.3 Parser un fichier HTML à la façon SAX
4. 4. Outils de manipulation de données
   1. 4.1 Encrypter une donnée
      1. 4.1.1 Fonctions de hashage
      2. 4.1.2 Code d’authentification de message
      3. 4.1.3 Stéganographie
   2. 4.2 Générer des nombres aléatoires
   3. 4.3 Expressions régulières
5. 5. Travailler avec des médias
   1. 5.1 Images
      1. 5.1.1 Représentation informatique d’une image
      2. 5.1.2 Présentation de PIL
      3. 5.1.3 Formats d’images matricielles
      4. 5.1.4 Récupérer des informations d’une image
      5. 5.1.5 Opérations d’ensemble sur une image
      6. 5.1.6 Travailler avec les calques ou les pixels
   2. 5.2 Sons
      1. 5.2.1 Représentation informatique du son
      2. 5.2.2 Installation de pymedia
      3. 5.2.3 Wav
      4. 5.2.4 MP3
      5. 5.2.5 Ogg Vorbis
      6. 5.2.6 Mutagen
   3. 5.3 Vidéos
      1. 5.3.1 AVI
      2. 5.3.2 MPEG2
      3. 5.3.3 DivX ou Xvid
      4. 5.3.4 PyMedia

Génération de contenu

1. 1. PDF
   1. 1.1 Présentation
      1. 1.1.1 Format PDF
      2. 1.1.2 Avantages
      3. 1.1.3 Inconvénients
      4. 1.1.4 Présentation de la bibliothèque libre
   2. 1.2 Bas niveau
      1. 1.2.1 Bibliothèque de données
      2. 1.2.2 Canvas
   3. 1.3 Haut niveau
      1. 1.3.1 Styles
      2. 1.3.2 Flux de données
      3. 1.3.3 Création d’un visuel
      4. 1.3.4 Template de page
      5. 1.3.5 Page contenant plusieurs zones
2. 2. OpenDocument
   1. 2.1 Installation
   2. 2.2 openDocument Texte
      1. 2.2.1 Hello World
      2. 2.2.2 Styles
      3. 2.2.3 Tableau
   3. 2.3 openDocument Tableur
      1. 2.3.1 Principes généraux par rapport au texte
      2. 2.3.2 Particularités
      3. 2.3.3 Aller plus loin
   4. 2.4 openDocument Présentation
      1. 2.4.1 Principes généraux par rapport au texte et au tableur
      2. 2.4.2 Mise en page
      3. 2.4.3 Créer une page

Programmation parallèle

1. 1. Terminologie
   1. 1.1 Processus
   2. 1.2 Tâche
2. 2. Utilisation d’une tâche
   1. 2.1 Gestion d’une tâche
      1. 2.1.1 Présentation
      2. 2.1.2 Création
   2. 2.2 Gestion de plusieurs tâches
      1. 2.2.1 Lancement et contrôle
      2. 2.2.2 Opportunité d’utiliser une tâche
   3. 2.3 Résolution des problématiques liées
      1. 2.3.1 Synchronisation
      2. 2.3.2 Synchronisation conditionnelle
      3. 2.3.3 Sémaphore
3. 3. Utilisation de processus
   1. 3.1 Gestion d’un processus
      1. 3.1.1 Présentation
      2. 3.1.2 Création
   2. 3.2 Gestion de plusieurs tâches
      1. 3.2.1 Synchronisation
      2. 3.2.2 Paralléliser un travail
   3. 3.3 Résolution des problématiques liées
      1. 3.3.1 Communication inter-processus
      2. 3.3.2 Partage de données entre processus
   4. 3.4 Opportunité d’utiliser les processus
   5. 3.5 Démon
4. 4. Exécution asynchrone
   1. 4.1 Introduction
   2. 4.2 Présentation

Programmation système et réseau

1. 1. Présentation
   1. 1.1 Définition
   2. 1.2 Objectifs du chapitre
2. 2. Écrire des scripts système
   1. 2.1 Appréhender son système d’exploitation
      1. 2.1.1 Avertissement
      2. 2.1.2 Système d’exploitation
      3. 2.1.3 Processus courant
      4. 2.1.4 Utilisateurs et groupes
      5. 2.1.5 Constantes pour le système de fichiers
   2. 2.2 Gestion d’un fichier
      1. 2.2.1 Ouvrir un fichier
      2. 2.2.2 Lire un fichier
      3. 2.2.3 Écrire un fichier
      4. 2.2.4 Changer les droits d’un fichier
      5. 2.2.5 Changer de propriétaire ou de groupe
      6. 2.2.6 Récupérer des informations sur un fichier
      7. 2.2.7 Supprimer un fichier
   3. 2.3 Alternatives simples à des commandes bash usuelles
      1. 2.3.1 Répertoires
      2. 2.3.2 Fichiers
      3. 2.3.3 Module de haut niveau
      4. 2.3.4 Recherche d’un fichier
   4. 2.4 Exécuter des commandes externes
      1. 2.4.1 Exécuter et afficher le résultat
      2. 2.4.2 Exécuter et récupérer le résultat
   5. 2.5 Utilitaires
      1. 2.5.1 Différentiel entre fichiers
      2. 2.5.2 Utilitaire de sauvegarde
      3. 2.5.3 Lire un fichier de configuration
      4. 2.5.4 Pickle
   6. 2.6 Compresser et décompresser un fichier
      1. 2.6.1 Tarfile
      2. 2.6.2 Gzip
      3. 2.6.3 Bz2
      4. 2.6.4 Zipfile
      5. 2.6.5 Interface de haut niveau
3. 3. Travailler avec des arguments
   1. 3.1 Présentation
   2. 3.2 Mise en œuvre
4. 4. Programmation réseau
   1. 4.1 Écrire un serveur et un client
      1. 4.1.1 Utilisation d’une socket TCP
      2. 4.1.2 Utilisation d’une socket UDP
      3. 4.1.3 Création d’un serveur TCP
      4. 4.1.4 Création d’un serveur UDP
      5. 4.1.5 Un peu plus loin sur le sujet
   2. 4.2 Utiliser un protocole standard
      1. 4.2.1 HTTP
      2. 4.2.2 Proxy
      3. 4.2.3 Cookies
      4. 4.2.4 FTP et SFTP
      5. 4.2.5 WEBDAV
      6. 4.2.6 SSH
      7. 4.2.7 POP et POPS
      8. 4.2.8 IMAP et IMAPS
      9. 4.2.9 SMTP et SMPTS
      10. 4.2.10 NNTP
      11. 4.2.11 IRC
   3. 4.3 Services web
      1. 4.3.1 REST
      2. 4.3.2 SOAP
      3. 4.3.3 Pyro
5. 5. Utilisation du matériel
   1. 5.1 Wake-on-LAN
      1. 5.1.1 Pré-requis
      2. 5.1.2 Mise en œuvre
   2. 5.2 Utilisation du port série

Bonnes pratiques

1. 1. Programmation dirigée par les tests
   1. 1.1 Tests unitaires
      1. 1.1.1 Principes
      2. 1.1.2 Interprétation
      3. 1.1.3 Couverture
      4. 1.1.4 Outils
   2. 1.2 Tests de non-régression
      1. 1.2.1 Actions de développement
      2. 1.2.2 Gestion de la découverte d’une anomalie par une MOA
   3. 1.3 Tests fonctionnels
   4. 1.4 Tests de performance
   5. 1.5 Intégration continue
2. 2. Programmation dirigée par la documentation
   1. 2.1 Documentation interne
      1. 2.1.1 À destination des développeurs
      2. 2.1.2 À destination des utilisateurs
   2. 2.2 Documentation externe
      1. 2.2.1 Présentation
      2. 2.2.2 Démarrage rapide
      3. 2.2.3 Résultat
3. 3. Optimisation
   1. 3.1 Qualimétrie
   2. 3.2 Outils de débogage
   3. 3.3 Outils de profilage
   4. 3.4 Règles d’optimisation
      1. 3.4.1 Pourquoi optimiser ?
      2. 3.4.2 Règles générales

Créer une application web en 30 minutes

1. 1. Description de l’application à construire
2. 2. Mise en place
   1. 2.1 Isolation de l’environnement
   2. 2.2 Création du projet
   3. 2.3 Paramétrage
   4. 2.4 Premiers essais
3. 3. Réalisation de l’application
   1. 3.1 Modèles
   2. 3.2 Vues
   3. 3.3 Contrôleurs
   4. 3.4 Traduction
4. 4. Pour aller plus loin

Créer une application console en 10 minutes

1. 1. Objectif
2. 2. Parseur d’arguments
3. 3. Création des données

Créer une application graphique en 20 minutes

1. 1. Objectif
   1. 1.1 Fonctionnel
   2. 1.2 Technique
2. 2. Présentation rapide de TkInter et d’astuces
3. 3. Gestionnaire de données
4. 4. Création des composants graphiques
5. 5. Autres bibliothèques graphiques
   1. 5.1 wxPython
   2. 5.2 PyGTK
   3. 5.3 PyQt
   4. 5.4 PySide

Créer un jeu en 30 minutes avec PyGame

1. 1. Présentation de PyGame
2. 2. Réalisation d’un jeu Tetris
   1. 2.1 Présentation du jeu
   2. 2.2 Présentation des problématiques
   3. 2.3 Création des constantes

Introduction à Grok en 10 minutes

1. 1. Présentation
   1. 1.1 Zope2
   2. 1.2 Zope3
   3. 1.3 Grok
2. 2. Mise en place
   1. 2.1 Création de l’environnement virtuel
   2. 2.2 Mise en place du projet
   3. 2.3 Observations
3. 3. Développement
   1. 3.1 Objectif
   2. 3.2 Description du composant principal
   3. 3.3 Vue Index
   4. 3.4 Vue d’édition
   5. 3.5 Vue d’ajout de contenu
4. 4. Conclusion

Annexes

1. 1. Applications scriptables en Python
   1. 1.1 GIMP
   2. 1.2 Inkscape
   3. 1.3 Blender
   4. 1.4 OGRE
   5. 1.5 Scribus
   6. 1.6 LibreOffice
   7. 1.7 KOffice
   8. 1.8 VLC, Amarok, BlueMindo, Quod Libet
   9. 1.9 Pidgin, Empathy
   10. 1.10 Firefox, Thunderbird
2. 2. Table UNICODE
   1. 2.1 Script
3. 3. Bytes
   1. 3.1 Script
   2. 3.2 Résultat
6. Index