Ce livre sur l'apprentissage de la Programmation Orientée Objet avec le langage Python s'adresse à toute personne désirant maîtriser ce type de programmation. Des connaissances de base en développement et sur la syntaxe du langage Python sont des prérequis indispensables pour tirer le meilleur profit du livre.

Dans une première partie l'auteur présente en détail les concepts de la POO : sa puissance d'expression qui lui a conféré son succès, les classes avec leurs attributs et méthodes, l'héritage qui ouvre la voie au polymorphisme, l'encapsulation qui permet un contrôle précis sur l'exposition des données... Avec des exemples simples et détaillés, la théorie de ce paradigme de programmation devient clairement accessible.

Ensuite, après quelques conseils pour installer un environnement de travail performant (utilitaire de gestion de modules externes, documentation du langage, outils de tests...), l'auteur propose la mise en application des chapitres précédents avec du code Python. Chaque concept de POO est explicité en profondeur et illustré par du code pertinent. Là encore, des exemples complets et commentés permettent d'appréhender parfaitement la puissance qu'offre le langage.

Au-delà du périmètre de la POO, les chapitres suivants traitent de sujets que n'importe quel développeur rencontrera au cours de sa carrière, et qui lui serviront au quotidien : la présentation de quelques design patterns pour une mise en pratique concrète des notions vues précédemment, et des exemples d'utilisation de bibliothèques Python spécialisées dans différents domaines de l'informatique (XML, interface graphique, multithreading...).

Et enfin, parce que la programmation ne consiste pas uniquement à écrire du code, l'auteur partage sa vision du métier de développeur, avec des conseils pour s'améliorer continuellement, travailler en bonne harmonie avec une équipe, ou encore savoir utiliser les bons outils dans les bonnes situations.

À la fin de chaque chapitre, l'auteur propose des exercices avec leurs corrigés pour permettre au lecteur de consolider ses acquis. Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.


Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (4 Ko)

L'émergence de la POO

1. 1. Ancêtres de la POO
2. 2. Besoin d'un langage de plus haut niveau

Les concepts de la POO

1. 1. Modélisation
2. 2. Objet et classe
3. 3. Encapsulation
4. 4. Agrégation et composition
   1. 4.1 Agrégation
   2. 4.2 Composition
5. 5. Interface
6. 6. Énumération
7. 7. Héritage
   1. 7.1 Héritage simple
   2. 7.2 Classe abstraite
   3. 7.3 Héritage multiple
   4. 7.4 Du « bon » usage de l'héritage
8. 8. Diagramme UML
   1. 8.1 Structure vs comportement
   2. 8.2 Diagramme de cas d'utilisation
   3. 8.3 Diagramme de séquence
9. 9. Exercices corrigés
   1. 9.1 Classe simple
   2. 9.2 Relations entre classes
   3. 9.3 Héritage ?
   4. 9.4 Repérage des classes
   5. 9.5 Contenants et contenus
   6. 9.6 Membres

Présentation de l'environnement Python

1. 1. Python, troisième du nom ?
2. 2. Installation
   1. 2.1 python.org
   2. 2.2 Windows
   3. 2.3 Mac OS X
   4. 2.4 Unix/Linux
3. 3. Outillage
   1. 3.1 pip
   2. 3.2 IDLE
   3. 3.3 PyCharm
4. 4. Quelques concepts de base de Python
   1. 4.1 Introduction
   2. 4.2 Philosophie
   3. 4.3 Langage interprété et compilé
   4. 4.4 Duck typing
   5. 4.5 Modules

Les concepts de la POO avec Python

1. 1. Classe
   1. 1.1 Déclaration
   2. 1.2 Instance
   3. 1.3 Membres d'une classe
      1. 1.3.1 Attribut
      2. 1.3.2 Méthode
   4. 1.4 Constructeur
   5. 1.5 Destructeur
   6. 1.6 Exercices
      1. 1.6.1 Palindrome - méthode de classe
      2. 1.6.2 Palindrome - méthode d'instance
      3. 1.6.3 Puzzle
      4. 1.6.4 Logger
2. 2. Héritage
   1. 2.1 Construction
   2. 2.2 Polymorphisme
   3. 2.3 Héritage multiple
   4. 2.4 Exercices
      1. 2.4.1 Héritage « simple »
      2. 2.4.2 Puzzle
      3. 2.4.3 Héritage multiple - Diamant et paramètres de constructeur
      4. 2.4.4 Héritage multiple - Cas « réel »
3. 3. Agrégation et composition
   1. 3.1 Agrégation
   2. 3.2 Composition
   3. 3.3 Exercices
      1. 3.3.1 Le jour d'après
      2. 3.3.2 Immortel ?
      3. 3.3.3 Alternative à l'héritage multiple
4. 4. Exception
   1. 4.1 Levée
   2. 4.2 Rattrapage
   3. 4.3 Éviter le masquage d'exception
   4. 4.4 Exception personnalisée
   5. 4.5 Exercice
5. 5. Concepts de la POO non natifs
   1. 5.1 Classe abstraite
   2. 5.2 Interface
   3. 5.3 Encapsulation
6. 6. Énumération
7. 7. Duck typing

Un aperçu de quelques design patterns

1. 1. Introduction
2. 2. Singleton
3. 3. Visiteur
   1. 3.1 Présentation
   2. 3.2 Exercice
4. 4. Modèle - Vue - Contrôleur (MVC)
   1. 4.1 Présentation
   2. 4.2 Exercice
5. 5. Abstract Factory
   1. 5.1 Présentation
   2. 5.2 Exercice

Plus loin avec Python

1. 1. Introduction
2. 2. XML
   1. 2.1 Présentation
   2. 2.2 DOM
      1. 2.2.1 Lecture
      2. 2.2.2 Méthode par accès direct
      3. 2.2.3 Méthode par analyse hiérarchique
      4. 2.2.4 Écriture
   3. 2.3 SAX
      1. 2.3.1 Lecture
      2. 2.3.2 Écriture
3. 3. JSON
4. 4. IHM
   1. 4.1 Tkinter
      1. 4.1.1 Création d'une fenêtre
      2. 4.1.2 Ajout de widgets
      3. 4.1.3 Gestion des événements
   2. 4.2 Qt
      1. 4.2.1 Présentation
      2. 4.2.2 Création d'une fenêtre
      3. 4.2.3 Ajout de widgets
      4. 4.2.4 Gestion des événements
5. 5. Bases de données
   1. 5.1 Présentation
   2. 5.2 SQLite
6. 6. Multithreading
   1. 6.1 Présentation
   2. 6.2 Python et la programmation concurrente
   3. 6.3 Utilisation du module threading
   4. 6.4 Synchronisation
   5. 6.5 Interblocage
7. 7. Développement web
   1. 7.1 Présentation
   2. 7.2 Création d’un projet Django
   3. 7.3 Développement web MVC
   4. 7.4 Quelques utilitaires intéressants

Quelques bonnes pratiques

1. 1. Introduction
2. 2. S’assurer avec des bases solides
   1. 2.1 De l'importance du socle
   2. 2.2 Structures de données et algorithmes communs
   3. 2.3 Un problème, plusieurs solutions
   4. 2.4 Choisir et maîtriser le bon outil
3. 3. Rester concis et simple
   1. 3.1 DRY
   2. 3.2 KISS
4. 4. Harmoniser l’équipe
   1. 4.1 Rédiger des conventions d’écriture
   2. 4.2 Revoir le code, tous ensemble
   3. 4.3 Documenter
   4. 4.4 Tester
   5. 4.5 Installer un environnement de déploiement continu
5. 5. Rejoindre une communauté
   1. 5.1 Participer à des conférences et groupes utilisateurs
   2. 5.2 Écouter la sagesse des foules
6. 6. Maîtriser les problèmes récurrents
   1. 6.1 Débogage
   2. 6.2 Traces
   3. 6.3 Monitoring
   4. 6.4 Performance
   5. 6.5 ETL
   6. 6.6 Bases de données : relationnelles ou non
   7. 6.7 Bases de données et ORM
   8. 6.8 Intégrations
   9. 6.9 Autres environnements logiciels
7. 7. Poursuivre sa croissance personnelle
   1. 7.1 Savoir poser des questions
   2. 7.2 Open source
   3. 7.3 Architecture
8. 8. Poursuivre sa croissance professionnelle
   1. 8.1 L'humain
   2. 8.2 Développement rapide et itérations
9. 9. Conclusion
12. Index