Python

Malgré ses apparences de simplicité, Python permet de développer de manière industrielle des logiciels de grande taille, avec notamment les assurances qualité nécessaires. Ce livre part d'un bon niveau de connaissance de Python, mais mène le lecteur à une maîtrise du langage et de ses mécanismes qui permettent d'écrire du code de manière pythonique, tout en nuance (parfois en développant des vues pas spécialement répandues sur ces fonctionnalités). Chaque chapitre est copieusement illustré en exemples, y compris avec des exemples d'utilisation (écrits sous la forme de doctests).

L'ouvrage aborde une grande série de sujets, mais approfondit surtout les annotations de types (et les cas où elles ne sont pas utiles) et les mécanismes de programmation asynchrone. La première moitié (parties 1 et 2) montrent comment exploiter les fonctions existantes de Python, tandis que la suivante (parties 3 et 5) se focalise sur l'écriture de classes, notamment avec de la métaprogrammation. La partie 4, quant à elle, est axée sur la programmation concurrente avec les mécaniques asynchrones récemment ajoutées dans le langage. Ce faisant, l'auteur explique comment fonctionne l'interpréteur Python, en allant par exemple jusqu'au MRO (method resolution order) dans le cas de l'héritage. Certains détails sont uniquement présents sur le site accompagnant le livre.

Chaque chapitre se termine par un résumé des idées principales et une liste d'articles ou livres pour approfondir les sujets abordés. De manière plus intéressante, les chapitres se concluent tous par une tribune, où l'auteur exprime son opinion ou retrace l'historique de certains mécanismes.

Globalement, ce livre de très bonne facture s'adresse aux utilisateurs déjà expérimentés de Python et leur ouvre tout un champ de possibilités qu'ils n'osaient pas imaginer pour ce langage. Ce livre détaille la manière dont Python implémente les mécanismes qui ont fait son succès, afin de les exploiter au mieux dans son code (si cela devait s'avérer nécessaire).

Contrairement à ce qu'indique son titre, cet ouvrage ne présente pas Python à des programmeurs, mais bien la programmation à l'aide de Python à des personnes n'ayant aucune expérience en programmation, peu importe le langage, avec des prérequis extrêmement faibles. Contrairement à d'autres livres avec le même objectif, celui-ci accorde une grande importance à la pratique, avec des exercices proposés tout au long de l'ouvrage (accompagnés de leur correction en ligne) et trois projets complets (chacun développé en trois chapitres) : développement d'un jeu, d'une application Web et d'une visualisation de données, trois domaines dans lesquels Python excelle. La pédagogie mise en place fait partie des meilleures pratiques pour l'enseignement de la programmation.

Bien que destiné à un public de développeurs en devenir, l'auteur cherche à montrer par l'exemple les meilleures pratiques actuelles de développement en Python, notamment en ce qui concerne le paradigme orienté objet. Le contenu est très pragmatique et non dogmatique, bien adapté au public cible.

Pour les débutants, les messages d'erreur sont souvent cryptiques, c'est pour cela qu'une partie s'attelle à leur déchiffrage. On peut toutefois regretter que le chapitre sur les ressources en ligne pour obtenir de l'aide ne soit qu'une traduction du texte anglais, sans aucune adaptation au monde francophone.

Cet ouvrage se dit être un guide pour les débutants en programmation, offrant une description complète du langage Python ainsi que des fonctionnalités de base, le tout, accompagné de nombreux exemples.

Le livre est composé de cinq grandes parties :
• l’introduction qui est à mon avis bien trop longue : 110 pages sur l’histoire des langages informatiques ;
• la présentation de Python et pourquoi le choisir ;
• un ensemble de minitutoriels, puis le langage Python en lui-même ;
• la manipulation de données au travers de bibliothèques ;
• et à la fin, des projets permettant ainsi de consolider l’apprentissage.

Ce livre est progressif, bien expliqué et j’ai trouvé l’architecture des chapitres cohérente avec un apprentissage partant de zéro. Chaque nouvelle information sur le langage est accompagnée d’exemples concrets afin de mettre en pratique la richesse de ce langage.

C’est un très bon livre, que ce soit pour débuter ou pour se perfectionner.

Cet ouvrage s'articule autour d'un mini-projet domotique allant de la lecture des senseurs alimentant un bus de messages pour, finalement, fournir une application web pour la gestion de son installation. Bien qu'abordant de nombreuses notions, tout est facile d'accès et vraiment bien illustré. Juste un niveau initié en Python et en Javascript est nécessaire pour appréhender correctement toutes les notions présentées. Par ailleurs, de nombreux exemples de code sont également fournis par l'auteur.

Une fois un apprentissage sommaire effectué, tout lecteur pourra envisager de réaliser soi-même ce qui, il y a quelques années, aurait été un vrai projet pour un professionnel aguerri. Pour cela, l'auteur a sélectionné un ensemble de composants matériels (ESP8266, BMP280, etc.) et de bibliothèques utilisables via Python (ou parfois MicroPython pour être exact), telles que le framework Flask. Même les principes de fonctionnement d'un broker type MQTT y sont résumés.

On trouvera sûrement des ressources plus détaillées sur chaque brique prise individuellement. Mais à ma connaissance, cet ouvrage est probablement le livre francophone le plus complet à ce jour pour réaliser un projet ne nécessitant pas de fines subtilités dans les composants présentés ; chaque partie méritant à elle seule l'acquisition comme didacticiel pour un débutant.

Ce livre est un guide permettant au lecteur de débuter et de prendre de bonnes bases avec le langage Python 3. Toutes les notions y sont décrites avec précision et détails, que ce soit la philosophie du langage, la création d'un exécutable, la création d'un site web, ou encore l'implémentation de tests. Pour cela, la première partie rappelle l'historique des langages et du langage Python en particulier. Elle offre un aperçu de sa réussite au sein du monde professionnel et amateur. Ensuite, la seconde partie du livre décrit intégralement le langage ainsi que les structures de données offertes aux programmeurs. De plus, la section se finit sur la description des patrons de conception les plus courants. Chaque élément décrit est accompagné d'un exemple permettant de s'approprier Python par l'expérimentation. Le troisième chapitre couvre les utilisations possibles du langage que ce soit de la génération d'un PDF, à la connexion d'une BDD, en passant par la réalisation de scripts système. La partie se termine sur les bonnes pratiques, les méthodes de débogage, la documentation, les tests et l'optimisation. Finalement, le livre se conclut sur une mise en pratique du langage au travers de la réalisation d'un mini site web, d'une application console et d'une application graphique. En guise de conclusion, vous trouverez une implémentation de Tetris avec pygame.

Ce livre est bon, mais la quantité ne doit pas tromper. L'introduction en elle-même est déjà grande (rappel de l'historique des langages, paradigmes de programmation et comparaison avec les autres langages) et pourtant il n'y a pas d'explication sur comment lancer son premier programme. De la même manière, les EDI sont présentés en quelques phrases, mais l'auteur ne donne pas de direction. Il est évident que chacun d'entre nous possède ses goûts, mais pour les débutants, il peut être bon d'être dirigiste.
Aussi, un déséquilibre s'installe au cours de la lecture : est-ce que le livre cible des programmeurs connaissant le langage, ou des débutants ne connaissant pas la programmation ? La description du langage est très détaillée et donc abordable pour quelqu'un n'ayant pas d'expérience avec un langage de programmation. Toutefois, plusieurs fois l'ouvrage fait référence à d'autres langages (et même des notions) que n'aura pas un débutant. Chacune de ces mentions est un rappel montrant en quoi Python est meilleur.
De même, les exemples accompagnant les explications sont nombreux, mais il n'y a pas d'exercice récapitulatif, ou ne serait-ce que des exemples concrets (répondant à des besoins concrets de mise en pratique). Évidemment, le projet à la fin du livre pourrait répondre à cela, mais il est trop court, semblable à un hello world.

Finalement, ce livre risque de trôner sur votre bureau, tel un manuel de référence que vous ouvrirez pour vous remémorer telle ou telle chose sur le langage ou ses types de base. Aussi, si vous cherchez à faire une chose nouvelle avec le langage, le livre pourra servir de pointeur vous menant aux solutions adéquates. L'ouvrage ne suffira pas pour vous apprendre l'algorithmique et devra toujours être accompagné de documentation supplémentaire pour réaliser un projet.

Ce livre offre une description complète du langage Python ainsi que des fonctionnalités de base (interaction avec les structures de données, le système, les fichiers) afin de donner au lecteur un manuel de référence.
Ainsi, le livre pourra être utilisé par un programmeur expérimenté pour prendre en main rapidement le langage. En effet, ce dernier est décrit de manière théorique. Il faudra donc une connaissance de la programmation et une certaine aisance dans la matière est nécessaire pour pouvoir l’utiliser comme tel. Afin de donner tous les éléments nécessaires pour démarrer correctement, le livre se termine sur une description des outils pour manipuler les fichiers, communiquer sur le réseau ou encore réaliser une interface graphique avec Tkinter.
Sinon, cet ouvrage sera votre référence dans laquelle vous vous plongerez pour revoir les capacités de Python et comment les utiliser. Par ailleurs, on peut se demander si un tel livre est encore utile dans des jours où Internet est quasi omniprésent, d’autant plus que la documentation officielle est complète et que les exemples ne manquent pas, alors que ce livre n’en donne que très peu. Évidemment, en voyage, ce livre vous permettra de continuer vos développements sans craindre le blocage quant aux fonctionnalités du langage. Aussi, le support papier peut être un plus pour certains lecteurs.
Finalement, la lecture de l’ouvrage est malheureusement alourdie par la présence de nombreuses coquilles, surtout dans la seconde moitié du livre.

Cette version est beaucoup plus complète que la précédente (2 fois plus de pages que la version précédente). Tout Python est passé en revue: des fondamentaux (instructions de bases (if, for, ...), des objets de bases (entier, string, list, ...)) aux différents modules plus évolués (os, sys, re, Pickle, Tkinter, Thread ...).

Tous les modules, objets, fonctions sont accompagnés d'une explication succincte (de quelques lignes à une bonne dizaine) mais efficace, de quoi comprendre aisément comment l'utilisation de l'instance étudiée;

Ce livre permet donc d'avoir un aperçu rapide en quelques pages du potentiel de chaque module. Grâce à un sommaire précis et un index en fin de livre, vous pourrez retrouver rapidement les informations recherchées.

Le faible poids et le petit format vous permettra de le transporter partout (contrairement à Python en Concentré (que je recommande vivement) mais beaucoup plus complet). Il vous sera d'autant plus utile que vous n'avez pas accès à internet et à la Library Reference.

Quand j'ai commencé à lire "The Definitive Guide to Jython", je me suis dit : «Voilà un livre dédié à l'intégration de Python (Jython) avec Java». Mais, je me suis vite rendu compte que bien que cela soit un aspect important de l'ouvrage, il serait plus juste de dire qu'il s'agit d'un livre sur le langage de programmation Python mis en application à l'aide de l'implémentation Jython et traitant aussi de l'intégration avec Java.

The Definitive Guide to Jython s'adresse tant aux programmeurs débutants avec Python qu'aux développeurs qui seraient intéressés à scripter la plateforme Java à l'aide de Python. Il s'agit d'un très bon choix pour les débutants désirant apprendre ce langage sans nécessairement avoir un intérêt spécifique pour Jython. Pour les programmeurs Java, Jython offre un langage de scripts facile à apprendre qui permet une plus grande interactivité avec la plateforme Java et la possibilité de remplacer facilement certains outils qui manquent parfois de flexibilité (par exemple Ant). Finalement, les programmeurs Python peuvent voir en Jython un portail vers une vaste quantité de librairies, la possibilité d'approcher une clientèle corporative ainsi qu'un moyen pour atteindre de meilleures performances.

Je vais faire un survol des différents chapitres pour vous donner un aperçu du contenu du livre et terminer avec mes impressions personnelles pour le mot de la fin. Pour plus de détails, vous pouvez accéder à l'entièreté du livre en ligne à http://www.jython.org/jythonbook/en/1.0/. Cool ! N'est-ce pas ?

La première partie, les chapitres 1 à 8, porte sur le langage. Tout ce qui y est écrit s'applique également à la version C de Python à l'exception des chapitres 7 et 8 qui discutent de certaines spécificités propres à Jython.

Chapitre 1 Language and Syntax : Ce chapitre fait un survol rapide du langage.

Chapitre 2 Data Types and Referencing : Ici, on parle des différents types (entier, chaîne de caractères, liste, ensemble, dictionnaire), de leurs méthodes et comment les manipuler.

Chapitre 3 Operators, Expressions and Program Flow : Le titre dit bien de quoi il s'agit soit comment créer des expressions à l'aide des opérateurs et comment se servir de tout cela pour contrôler l'exécution du code.

Chapitre 4 Defining functions and using built-ins : Chapitre sur les fonctions, les générateurs, les décorateurs et les espaces de nommage. On montre, entre autres, comment se servir des coroutines.

Chapitre 5 Input and Output : Court chapitre sur la saisie clavier, les modes de lecture de fichiers, les méthodes de base, l'encodage et le formatage en sortie.

Chapitre 6 Object-Oriented Jython : Un chapitre sur les classes, la redéfinition et la surcharge de méthodes, les méthodes spéciales, les méthodes privées, le passage de paramètres et les arguments par défaut.

Chapitre 7 Exception Handling and Debugging : Un chapitre sur les exceptions, les différences avec le langage Java, la hiérarchie des différentes exceptions définies par le langage, une présentation du module warnings, les assertions et l'usage de with.

Chapitre 8 Modules and Packages for Code Reuse : Ici on parle de comment assembler le code en modules en parquetages. On y décrit les différents types d'importations, à quel moment les fichiers __init__ sont exécutés, les chemins d'accès (CLASSPATH et sys.path), la compilation et le chargement des modules. C'est un chapitre très complet et on va jusqu'à décrire comment il est possible d'ajouter de nouveaux systèmes de chargement de code.

La deuxième partie, les chapitres 9 à 12, est consacrée à la mise en application du langage. Voyons ce qu'on nous présente.

Chapitre 9 Scripting With Jython : Ce chapitre montre comment créer un script, comment traiter les arguments qui peuvent être passés en paramètres, comment naviguer dans un système de fichiers et il présente également comment Python peut servir d'outil pour compiler du code Java.

Chapitre 10 Jython and Java Integration : Voici un des chapitres que j'attendais avec beaucoup d'impatience. Il s'agit du chapitre consacré à l'interopérabilité du code Python avec Java. Employer le code Java du côté Python est très facile. Essentiellement, on importe le code Java comme on importerait un module Python. Cette facilité à employer le code Java en Python est certainement une grande réussite pour Jython. Par contre, faire l'inverse, employer le code Python du côté Java s'avère plus difficile. Le livre procède en présentant quelques techniques à l'aide d'exemples mais je trouve que la théorie se fait pauvre. Ce chapitre fait aussi mention de la JSR-223 et de comment employer directement l'interpréteur Python depuis Java.

Chapitre 11 Using Jython in an IDE : Ici un chapitre pratique sur l'emploi d'Eclipse et de Netbeans avec Jython. Malheureusement, bien que pratique pour certains, c'est un chapitre qui risque de devenir désuet rapidement tant les outils que l'implémentation du langage évoluent rapidement.

Chapitre 12 Databases and Jython (Object Relational Mapping and Using JDBC) : Ce chapitre traite principalement de ZxJDBC : un pont entre les API standard DBI de Python et l'interface JDBC de Java. Un sujet complexe qui est quand même bien couvert malgré le peu de pages qui lui est consacré. Quelques exemples d'accès aux bases de données y sont présentés. On fait mention de SqlAlchemy et d'Hibernate parmi les exemples.

La troisième partie s'intitule "Developing Applications with Jython". On présente comment intégrer Jython avec les servlets Java avec Django et Pylons ainsi que de l'intégration avec les composantes d'interfaces graphiques Swing de Java.

Chapitre 13 Simple Web Applications : Un chapitre qui montre comment on peut créer des servlets avec Jython. En y montrant aussi comment on peut créer une application Java Web Start ainsi que des archives jar autoéxécutables. Pour terminer, on montre comment il est possible d'embarquer un serveur WSGI en tant que simple servlet.

Chapitre 14 Web Applications With Django : Courte introduction à Django.

Chapitre 15 Introduction to Pylons : Oui, c'est une introduction à Pylons.

Chapitre 16 GUI Applications : Une introduction à Swing. Une petite application de messagerie instantanée est présentée en exemple.

Chapitre 17 Deployment Targets : Un court chapitre qui discute du déploiement sur différents serveurs Java et de Google App Engine ainsi que des problèmes qui peuvent survenir dans ce contexte. Un chapitre qui deviendra rapidement caduc mais qui est quand même utile.

Quatrième et dernière partie "Strategy and Technique". Cette partie traite des tests unitaires et de la concurrence.

Chapitre 18 Testing and Continuous Integration : Un chapitre étoffé sur l'utilisation des tests unitaires avec UnitTest et Nose présentés avec des exemples. On termine avec l'intégration continue à l'aide d'Hudson.

Chapitre 19 Concurrency : Le dernier chapitre est lui aussi très riche. Il porte sur les threads, leur emploi et sur différentes techniques pour bien gérer la concurrence. On y parle des différences entre Jython et la version C de Python.

Le livre se termine sur trois annexes très intéressantes. L'annexe A porte sur les spécificités de Jython et sa configuration. On présente comment il s'intègre avec Setuptools et Virtualenv. L'annexe B donne quelques recettes. Essentiellement, on présente des exemples sur l'emploi de librairies populaires du côté Java. La dernière annexe, C, est un index des fonctions standard du langage.

En bref, The Definitive Guide to Jython offre énormément de contenu en cinq cents pages. Beaucoup de matériel est couvert avec des exemples poussés. Le seul regret que j'ai c'est que le chapitre 10 sur l'interopérabilité du code entre Java et Python aurait dû à mon avis être plus détaillé. À part cet inconvénient, je ne peux que chaudement recommander ce livre aux développeurs Python et inviter les développeurs Java à découvrir ce que Python peut leur offrir.

Merci à Simon Yu d'Apress pour m'avoir offert ce livre.

L'ouvrage est plutôt bien écrit, résolument pragmatique et donc abordable par un débutant. Les chapitres s'enchaînent dans une difficulté croissante, correspondant à la montée en niveau d'un lecteur débutant. En revanche, il manque, selon moi, un fil conducteur à ce livre : une sorte de projet simple raffiné au fil des chapitres en illustrant les notions présentées.

Il faut signaler que très rapidement, les exemples sont orientés "graphique".

Quelques légers soucis avec l'ouvrage

• la partie "Licences logicielles" ne présente en fait que la GPL. Glisser un mot sur la version LGPL aurait sûrement été appréciée ;
• il en va de même pour la partie "Licences documentaires" qui se borne à la Creative Commons ;
• le passage sous silence des itérateurs me laisse pensif...
  

Dernier point à souligner : l'ouvrage est consultable gratuitement en ligne. Seule la version livre est payante. Ceci est un point positif pour les débutants, cible principale de l'ouvrage selon moi.

Certains disent de ce livre qu'il va leur donner les bases de Python 3 : sur la quatrième de couverture, c'est écrit noir sur blanc, le lecteur est censé avoir une expérience en programmation. Les premiers chapitres ne changent pas le ton, la syntaxe ne sera pas expliquée. En fait, il n'est pas nécessaire de déjà maîtriser la syntaxe de Python pour comprendre pleinement ce livre. Une expérience de programmation suffit ; les exemples sont donnés dans le bon ordre, c'est-à-dire par niveau croissant de difficulté ; les meilleures pratiques n'ont pas droit à tous les détails quand elles se limitent à la syntaxe (alors que l'auteur, même s'il a dit qu'il ne le ferait pas, donne le squelette de ce qui est nécessaire à leur compréhension). Il n'est absolument pas nécessaire d'avoir un tel bagage en Python ; cela ne peut qu'aider, bien évidemment, le lecteur pourra alors se plonger plus directement dans l'étude des exemples.

Tout au long du livre, l'auteur a parsemé des exemples - réalistes, complets, jusque quelques milliers de lignes pour PyMailGUI -, pas seulement quelques lignes éclaircissant un concept. On trouve des exemples pour faire comprendre tout ce qui est à comprendre du concept étudié, avec sur le côté d'autres exemples, plus longs, commentés en suffisance, entourés de quelques paragraphes d'explication, etc. On peut dire que l'auteur construit ses exemples étape par étape, il est impossible de s'y perdre. Même sur l'épineux sujet des threads, bête noire de tout développeur, il explique en détail ce qui doit l'être, les subtilités techniques n'ont plus de secret. Le tout étant utilisé dans des applications réelles. On trouve même des chapitres dédiés à l'étude d'un exemple, utilisant bien évidemment le code déjà écrit - la réutilisation du code est très importante.

Presque tout sujet principal sur Python est couvert : la programmation système (Python tend à remplacer les scripts Bash et Perl) ; les GUI (Python se montre aussi puissant que le C++ à ce niveau) ; Internet (Python est en plein essor avec des frameworks Web comme Django ou Zope, même si aucun des deux n'est couvert, aucun ne supporte Python 3 actuellement). Le principal problème se situe dans tout ce qui ne peut pas trouver sa place dans ce livre : ZODB, Zope, Django, MySQL, etc. ne sont pas encore portés sur Python 3 ; le livre ne couvrant que cette version de Python, ces sujets doivent être écartés de cette quatrième édition. Notons quand même que ZODB est montré avec Python 2 pour exposer l'utilisation des bases de données orientées objet.

Même si le livre semble impressionnant de par sa taille (1600 pages), il est presque impossible de couvrir autant de sujets en aussi peu de pages. Même si certains sujets auraient pu être couverts, le livre est plus que complet. Certains chapitres aident à comprendre les bases de choses qui ne sont pas couvertes volontairement (les scripts CGI sont expliqués, alors que plus personne ne songerait à les utiliser pour des projets Web modernes, même si les frameworks actuels sont basés sur ces principes).

Some thought this book was to give them the basics about Python 3.x; turn the book, it is written: the readers are supposed to have a "previous programming experience." The first chapters are no different, the syntax will not be explained. Actually, you do not need to know Python's syntax to fully understand the book. Programming experience is enough, examples are given in the right order, the best practices are explained not in full details when related to the core language (however, even if he said he will not, the author spends some lines outlining what is really needed). No, it is not required to have completely read a introductive text about Python; of course, it helps, the reader can get more quickly into the full depth of the examples.

Throughout the book you can find examples - realistic, complete (up to thousands of lines for PyMailGUI) -, not a few lines explaining only the concept; you will find there examples for you to understand everything about the studied concept, along with more detailed examples, with comments, concept explanation paragraphs, and the like. One can say he builds his examples step by step, no one can get lost - even when he starts with threads, a subject many developers just do not like, he manages to make everyone completely aware of all those technical subtleties about beginning with threads. Everything here is also shown in use in real world applications.
Examples also mean that the whole book is not all about theory, there are some examples chapters, chapters totally dedicated to a single example, using many snippets written before (code reutilisation is important).

Almost every main subject in Python is covered: system programming, as Python is a replacement for Perl, Bash scripts, etc.; GUIs, as Python can do as much as C++ can in the GUIs' world; Internet, as Python is growing fast with frameworks like Django or Zope (even though any of these is covered: none currently supports Python 3). The main problem is that important things cannot find a place in that book: ZODB, Zope, Django, MySQL, etc. are not yet ported to Python 3; the book only covers Python 3 and thus cannot say much about these. Note that ZODB is shown, in its Python 2 flavour, to show the basics about OODB; wilingly, no Web framework is getting more than a paragraph or two, these technologies are said to change often.

Though this is an impressive book (about 1,600 pages), it is almost impossible to cover so many subjects in so few pages. Even if it lacks a few topics, this book is more than far complete. Some chapters help you understand the basics of things that cannot be covered (CGI scripting is shown, it is not used anymore for new Web projects, but current Web frameworks are based on these principles).

Mark Summerfield déjà co-auteur du célèbre livre C++ GUI Programming with Qt 4 (traduit en français aux éditions Pearson Education) nous livre un nouvel opus sur la librairie Qt4 mais dédiée cette fois-ci au langage Python.

Parlons de la qualité du livre lui-même : une belle couverture rigide sur laquelle figure l'image du satellite Hubble en orbite autour de la Terre. Le sens ? Python est utilisé par la NASA pour calibrer et analyser les données recueillies par celui-ci. Que ce soit le papier, la qualité d'impression ou les multiples diagrammes, il n'y a rien à redire si ce n'est qu'on aimerait voir ce genre d'initiatives plus souvent chez nos éditeurs, surtout eu égard au prix pratiqué.

Passons maintenant au contenu proprement dit, qui se divise en quatre parties distinctes (cinq en fait si l'on compte les divers appendices qui représentent à eux seuls presque une centaine de pages).

• Programmation avec Python ;
• Programmation d'interfaces graphiques niveau basique ;
• Programmation d'interfaces graphiques niveau intermédiaire ;
• Programmation d'interfaces graphiques niveau avancé.
  

On peut s'interroger sur le bien fondé de la première partie, en effet il serait étonnant qu'une personne ne connaissant pas le langage se risque à acheter un tel livre. Et pourtant Marc réussi là un véritable tour de force : on balaye les fonctionnalités du langage par la pratique, avec des exemples vraiment très pertinents. J'avoue même avoir appris certains concepts dont je ne soupçonnais pas l'existence, sans doute faute d'en avoir eu un réel besoin. Les fonctions partielles, par exemple, ont un intérêt certain dans la suite de l'ouvrage. De la même façon, vous pourrez y voir de multiples références au PEP (Python Enhancement Proposals : les fonctionnalités à venir de Python).

Si l'anglais peut rebuter au départ, surtout lorsqu'il est technique, on se surprend rapidement à lire un thème donné sans avoir recours au dictionnaire (je précise que je n'ai aucune thèse en anglais). Le style se veut simple et efficace, sans être simpliste.

Autant vous rassurer tout de suite, le contenu des trois parties consacrées au vif du sujet, la programmation d'interfaces graphiques n'est pas du tout un plagiat du livre précédent : C++ GUI Programming with Qt 4. On y aborde évidemment plus ou moins les mêmes sujets, mais un réel travail a été fourni sur les nouvelles fonctionnalités apparues depuis la version 4.2 de Qt 4. Citons par exemple un chapitre entier consacré à l'architecture du Graphics view : un réel plus par rapport au livre précédent.

Les exemples sont abondants, collent à la pratique et vous pourrez en outre les récupérer gratuitement sur la page que Marc à consacré à son ouvrage. Sachez du reste qu'elle est remise à jour régulièrement, afin d'améliorer encore certains exemples et de proposer un errata.

Citons aussi quelques petits cadeaux vraiment bienvenus : des utilitaires écrits par l'auteur afin de gérer au mieux vos projets PyQt 4. À chaque fois, on vous place en situation de développeur et vous serez amené à résoudre quelques exercices proposés en fin de chapitre.

J'ai beaucoup apprécié l'éventail d'alternatives à un problème donné. Comment imprimer le contenu d'un QTextEdit par exemple ? Marc vous propose trois méthodes abondamment commentées, de la plus simple à la plus complexe, à vous de choisir ensuite en fonction de vos besoins, de votre niveau ou du temps que vous allez y passer.

Vous l'aurez donc compris, j'ai été plus que séduit par ce livre. On ne passe pas son temps à comparer Qt à tel autre toolkit comme le font certains ouvrages (d'ailleurs, serait-ce vraiment la peine ?), on pratique avant tout, et les repères ne manquent pas: index abondants, diagrammes de classes, éventail visuel de tous les widgets.

Des critiques ? Un chapitre de C++ GUI Programming with Qt 4 était consacré au développement de plugins avec C++, il est absent ici, comme dans tout livre sur Python consacré à ce vaste sujet. Il est vrai que les possibilités dynamiques qu'offrent Python permettent de pallier ce problème assez facilement, mais encore faut-il mettre la main à la pâte. S'il est absent, c'est à mon avis surtout parce qu'il n'existe pas de recette tout faite, mais j'aurais au moins aimé disséquer un exemple simple sur le sujet.

Enfin contrairement à beaucoup d'autres ouvrages, Rapid GUI Programming with Python and Qt se distingue aussi par la façon dont il a été écrit. Pas de LaTeX, de Scribus, de QuarkXPress ni même de InDesign ici, mais une alternative originale et légère : Lout.

Après une introduction en douceur reprenant l'ensemble des éléments qui vont être présentés, l'auteur aborde l'installation de tous les paquets nécessaires à l'analyse et à la visualisation de données. On continue par une petite introduction au langage lui-même. On n'aborde pas tout, cela est impossible et donc il faut avoir déjà vu un langage objet, à mon sens, ou avoir lu un ouvrage dédié au langage Python lui-même.

Deux chapitres sont dédiés à la gestion de la donnée et à son extraction d'un fichier. Comment est-ce que les données peuvent être stockées, comment peut-on parser les fichiers pour ne récupérer qu'une partie ? Toutes les réponses sont dans ces chapitres (même si on n'aborde pas les formats plus complexes comme XML, il faudra regarder l'aide directement) sous une forme simple et efficace.

L'affichage est un élément clé dans l'analyse ici, ce qui est principalement abordé par le module Matplotlib. Ce dernier est complexe, mais la présentation rend son utilisation aisée. Par la suite, les modules Numpy et Scipy sont aussi présentés, mais seulement dans une orientation d'analyse de données, donc les outils les plus avancés ne seront pas abordés.

Un dernier chapitre sera dédié aux modules très utiles mais non indispensables comme Pickle. On peut se passer de ce chapitre en première lecture, mais pour des analyses plus complexes, ils seront à connaître pour gagner du temps.

L'auteur a fait le pari de présenter uniquement la partie analyse de donnée et visualisation avec Python. Le texte est simple mais va au but. En lisant ce livre, on est capable de pouvoir réaliser 99% des traitements sur des données, comme faire des contrôles qualité graphiques. Le pari est donc remporté.

After a small introduction where all elements of the book are used for a simple example, the author tells us how to install Python and the different modules that will be needed for our task. Then, the langage itself is fastly introduced. If you don't know any object-oriented langage or Python, you may find the introduction too light, so you may need to read a book dedicated to the Python langage if you want to master it. It's obviously not the goal of the book.

Two chapters deal with data management and extracting it from a file. Why can data be stored? How to parse and retrieve what we need? The answer to these questions are in these chapters (even if the more complex formats as XML are not deal with, you'll have to dig in the documentation) in a simple and efficient way.

Display is of course the key element here. It's the Matplotlib module which has this responsibility. It's a complex module, but it is explained so that is is easy to use. Then Numpy, Scipy and PIL have each their chapter. They cannot be fully presented, only with a data analysis orientation. For more advanced functions, you will once again have to use the associated documentation.

The last chapter is dedicated to useful but not mandatory modules, like Pickle. This chapter can be skipped at first, but then the modules will help optimizing your time for more complex visualizations.

The author took the challenge of only showing the data analysis and visualization part of Python. The text is simple and goes straight to the point. By reading the book, one is able to do 99% of data analysis and quality controls (QCs). The challenge is thus a success

Matthieu BRUCHER propose un livre destiné à la programmation scientifique avec Python et surtout un livre pour les scientifiques. Ainsi, toute personne travaillant dans le domaine pourra profiter pleinement de cet ouvrage sans pour autant avoir au préalable une quelconque connaissance de Python. Il est néanmoins primordial d'avoir déjà de bonnes notions en programmation, vous risquez sinon de rapidement être dépassé par le rythme assez soutenu de l'ouvrage.

La moitié de l'ouvrage est consacré au langage Python et à sa bibliothèque standard, l'autre moitié couvre les bibliothèques indispensables au calcul scientifique NumPy, SciPy (pour le calcul matriciel, FFT, traitement du signal, algèbre linéaire, ...) ou encore Matplotlib. Le livre se termine par l'interfaçage entre Python et le C/C++.

La présentation du langage Python et de sa bibliothèque standard est assez dense mais les explications sont claires et les remarques intéressantes, le tout agrémenté de nombreux exemples simples, idéales pour quelqu'un qui a besoin de se plonger rapidement dans Python.

Pour NumPy et SciPy, Matthieu BRUCHER détaille un nombre très important de modules et fonctions de ces deux bibliothèques à la manière d'un manuel de référence. Ainsi, vous pourrez vous plonger régulièrement dans ces chapitres lorsque vous aurez besoin d'outils dans des domaines spécifiques. Le lecteur devra cependant souvent lui-même expérimenter les fonctions proposées, les exemples étant cette fois-ci relativement peu nombreux.

Le module Matplotlib est présenté par une succession d'exemples détaillés qui permet d'avoir un bon aperçu des possibilités de Matplotlib.

Enfin, Matthieu BRUCHER s'attaque à l'interfaçage entre Python et le C/C++ qui pour moi reste la partie la plus difficile à appréhender (ce qui est normal vu qu'il faut être à la fois être très à l'aise en Python et en programmation C ou C++). Mais les explications permettent une bonne entrée en matière à ceux qui auront besoin de profiter de la puissance de calcul du C/C++ dans leur programme Python (rassurez-vous, il est encore possible de se passer de tout ceci en travaillant un maximum avec les nombreuses bibliothèques externes disponibles avec Python, souvent développées en C ou C++, comme leurs concepteurs ont fait l'effort de créer les fichiers d'interface indispensables).

Il est sûr qu'un habitué de Python aurait préféré un livre entièrement consacré aux bibliothèques de calcul scientifique mais ce n'était pas l'unique objectif de Matthieu BRUCHER. Je le félicite de plus d'être le pionner dans l'écriture d'un livre en français consacré à ce domaine.

Voici un livre unique en son genre. Comme vous pouvez le voir sur la table des matières, Matthieu Brucher introduit le langage Python en premier lieu, ce qui s'avère très efficace. En effet, ce langage est assez simple à aborder et l'auteur ne fait que faciliter les choses grâce à de bonnes explications, qui vont droit au but, ainsi que grâce à de nombreux exemples.

Ensuite, il s'agit de consolider ses connaissances en python à travers des exemples plus intéressants, qui abordent le XML, le réseau, la compression, le multithreading, etc, ce qui amène le lecteur à faire des essais, à comprendre. J'ai tenu à décrire ce début de livre car c'est à mon avis une très bonne approche qui prépare très bien pour la suite.

C'est à ce moment-là que les choses sérieuses commencent. L'auteur, à partir de ce moment vise particulièrement les scientifiques (bien qu'il ne ferme pas la compréhension aux autres). Matthieu Brucher dédie une grosse partie du livre à des bibliothèques scientifiques utilisables en Python. En effet, une fois la syntaxe et les quelques subtilités du langages acquises, le lecteur a un niveau suffisant pour s'intéresser à la représentation des matrices, la transformée de Fourier, le traitement de signal et tant d'autres choses, en Python. Il s'agit donc à partir de ce moment là de considérer Python non plus comme un "simple langage de programmation" mais comme un outil scientifique pour le calcul, le traitement, la résolution, par exemple. L'auteur aborde donc un large spectre des possibilités de ces bibliothèques Python jusqu'à la fin du livre, en terminant avec l'intéraction entre Python et C/C++.

Ce qui m'a plu dans ce livre, bien que connaissant déjà la programmation (mais peu le langage Python), est la façon dont est abordé le langage. L'élévation du niveau est progressive, mais entraine une motivation due au fait que la programmation se concrétise : on est ensuite capable de se servir de Python comme de Matlab, ou comme tout autre outil de ce genre. De plus, Python étant un langage de programmation simple mais pourtant offrant tellement de possibilités, on peut écrire des applications réellement puissantes : aller chercher un fichier xml à une adresse donnée, récupérer des informations relatives à un signal, construire puis effectuer des traitements sur le signal, tracer différents graphiques, etc. Le sujet choisi par l'auteur est excellent et la mission est réussie. Il y a toutefois une seule chose qui pourrait déranger : ne rien connaître à la programmation ni à l'algorithmie. En effet, l'auteur ne passe pas des pages et des pages à décrire une notion simple. Les explications sont efficaces et seront comprises par, à mon avis, toute personne concernée par ce livre.

C'est très simple: c'est le livre que je conseille à tous les débutants souhaitant apprendre le langage Python. C'est aussi le livre que j'ai utilisé pour faire mes premiers pas avec Python.

L'entrée en matière dans le langage Python est concue de telle sorte que même un débutant en programmation ne sera jamais perdu. Ainsi avec les 6 premiers chapitres, vous apprendrez les bases du langage.
La suite n'est pas forcément à lire linéairement. Vous retrouverez ce qui est nécessaire dans tout programme à savoir la construction de fonctions puis de classes. Concernant les classes, l'auteur se contente d'aborder principalement la construction des classes, l'héritage et le polymorphisme.
De gros efforts ont aussi été fait sur la programmation d'interface graphique avec le modèle Tkinter avec 4 chapitres y étant consacrés.
Enfin, quelques notions supplémentaires intéressantes (comme le web, les bases de données ou encore les communications réseaux) apparaîssent en fin d'ouvrage. L'auteur met l'accent sur ce qui est vraiment utile et nécessaire, si bien que même si vous ne serez pas des experts sur ces thèmes, vous serez aptes à les utiliser directement dans vos propres programmes sans avoir besoin de rechercher nécessairement d'autres informations ailleurs.

La clarté de l'ouvrage n'est jamais prise en défaut. Du début à la fin, l'auteur ne s'affranchît jamais de ne pas expliquer clairement les notions abordées. Tous les codes sources des exemples sont complétés de commentaires et d'explications qui devraient vous permettre de les lire et comprendre facilement et très vite. Enfin, chaque chapitre est agrémenté d'exercices corrigés qui vous permettront réellement de vérifier que vous avez compris les notions abordées. Ainsi, il restera une trace dans votre esprit de tout ce que vous lirez dans ce livre.

Une version pdf est également disponible sur nos pages cours Python qui vous permettra également de voir la table des matières complète de l'ouvrage.

La publicité appelle ce livre l'ouvrage de référence pour le développeur Python, et pour une fois, on ne peut que confirmer.

Selon moi, le lecteur devra soit avoir déjà débuté son apprentissage de Python en tant que premier langage, afin de ne pas être perdu au milieu de tous les termes usuels de ce domaine, soit connaître déjà un langage de programmation classique, et a priori n'avoir besoin que de la syntaxe pour aborder les premiers chapitres -- et fort heureusement, la syntaxe y est justement détaillée étape par étape.

A priori, vous y trouverez des explications sur tout ce qui est disponible en standard dans le langage... les structures de données (séquences, dictionnaires, etc), les paradigmes de programmation disponibles (impératif/procédural, impératif/objet, fonctionnel), et même une partie système qui vous permettra d'effectuer aisément certaines tâches propres à votre OS (en fait seul Windows et les Unixoïdes sont détaillés, mais ça couvre 99% des besoins).

Les débutants y trouveront même des exercices corrigés pour les guider dans leur apprentissage.

En résumé, un excellent livre à un tarif abordable (environ 30?), ce qui est assez rare pour ce type d'ouvrage.

Ce premier volume est entièrement consacré aux bases de Python en parcourant également beaucoup de notions de la programmation fonctionnelle et objet, le tout se concordant avec la version de Python 2.5. Comme je possède déjà de bonnes connaissances en Python, mon point de vue peut cependant être un peu biaisé. Ce livre est en effet destiné plutôt à des programmeurs connaissant déjà un langage de programmation ou ayant néanmoins des bases en programmation.

Ce livre me semble d'une lecture très aisée dans la mesure où les différentes notions abordées de chaque chapitre sont reprises plusieurs fois dans un même chapitre. Vous ne perdrez ainsi jamais le fil du cours même si certaines notions vous paraissent floues au premier abord. Pour des notions plus complexes (notamment en programmation objet), il est parfois bon de déjà les connaître ou alors de bien tester les exemples (toujours simples d'écriture mais parfois subtils). De toute façon, vous assimilerez facilement toutes les notions de bases de Python (syntaxe, nombres, listes, chaînes de caractères et fonctions associées) et vous serez aussi en mesure d'utiliser un maximum des propriétés de la programmation fonctionnelle et objet tout en profitant des énormes possibilités offertes par Python.

Toutefois, quelques coquilles m'ont sauté aux yeux dans les exemples (vous retrouverez cependant les erreurs et corrections détectées depuis (à partir de la version américaine) sur le site http://corepython.com/). Une indentation de 4 caractères classiquement utilisée au lieu de 2 ou 3 aurait aussi, je pense, apporté un peu plus de lisibilité dans le code de certains exemples. Concernant les exercices, leur nombre est une bonne chose mais il aurait été souhaitable qu'il y en ait plus de corrigés dans le livre ou bien que les corrections soient disponibles sur le web.

Ce livre est une bonne entrée en matière dans Python. Il ne se suffit cependant pas à lui-même pour profiter pleinement des possibilités de Python car les modules de la bibliothèque standard ne sont pas passés en revu. Le volume 2 vous permettra de découvrir certains de ces modules (concernant les expressions régulières, le réseau, le web, les threads, Tkinter, ...) Un autre ouvrage tel que Python en concentré peut aussi lui être associé pour avoir en plus l'occasion de découvrir tous les modules existants dans la distribution standard de Python.

L'auteur, Wesley Chun est un programmeur qui enseigne et utilise Python depuis bientôt dix ans déjà. Il a travaillé chez Yahoo et dirige maintenant une entreprise de génie logiciel en Python.

À qui s'adresse-t-il ?

À en croire les premières pages du livre, aucune connaissance n'est requise en programmation pour aborder le langage Python. Mais on verra plus loin que ceci n'est vrai que partiellement, ce qui n'enlève rien à l'intérêt du livre (bien au contraire).

Qualité

L'ouvrage se divise en deux tomes: le premier pour aborder les notions fondamentales, le second pour les celles avancées.

Les deux livres ont un papier bien blanc, épais et très agréable au toucher, sont reliés à la colle, ce qui ne les empêche pas de rester vraiment solide.

Ils ont en revanche une couverture que j'ai trouvé peu inspirée, la Terre avec une série de nombres en filigrane sur fond vert.

Le contenu

Le premier chapitre porte sur l'installation de Python, ses différences avec les autres langages et des suggestions d'IDE/éditeurs de texte. Si elles ne sont pas si nombreuses, elle ont au moins le mérite de rester d'actualité car on pourra noter par exemple les nouveaux produits de la firme ActiveState : Komodo Edit et Komodo IDE (la version 4.0.2 vient de sortir à l'heure où j'écris ces lignes).

On entre enfin dans le vif du sujet au chapitre 2 qui se veut un survol du langage. J'ai été un peu surpris par celui-ci, je m'attendais à quelque chose d'assez léger (et souvent pompeux, il faut le dire), mais on commence vraiment à comprendre là le titre du livre : "Au cœur de...", car on va loin (par ex. allusions aux passages d'arguments par pointeurs/valeurs ). Mais que cela ne vous rebute pas : on a le droit à du bon, du très bon même.

La suite traite de nombreux sujets. Elle est à mi-chemin entre une introduction sur un sujet donné, un recueil d'exemples et un manuel de référence. L'auteur abuse des mises en garde, et certains de ses conseils s'avèrent vraiment précieux pour la compréhension.

On se laisse vraiment divertir et les exemples ou exercices donnés (certains sont corrigés) se veulent pratiques et diversifiés, ce que je reprocherai à beaucoup d'ouvrages. Même si vous connaissez pas mal Python, Wesley Chun fait en sorte vous soyez surpris de temps à autres par de petites subtilités forts bien venues, c'est pourquoi je pense que le tome I s'avère indispensable, même pour un connaisseur.

Le tome II quant à lui aborde des sujets assez évolués, comme l'écriture d'extensions dans un langage de plus bas niveau, les expressions régulières et la programmation réseau.

Critiques

• Des coquilles persistent sur certains bouts de code, mais il faut avouer qu'il est difficile de les éviter surtout dans un ouvrage aussi volumineux ;
• Certains sujets ne sont pas abordés : XML et JSON par exemple n'ont pas une page alors qu'ils sont utilisés fréquemment ;
• Comme d'habitude, le chapitre concernant les interfaces graphiques se veut très limité (conséquence du fait qu'on ait plutôt l'embarras du choix avec Python). L'auteur n'a pas voulu faire de choix particulier et essaye d'en balayer quelques uns. A mon grand regret, PyQt4 n'est pas là, on invoque toujours les Copyrights mais TrollTech à beaucoup évolué là-dessus. Aussi, si vous désirez aller plus loin sur le sujet, il vous faudra acheter un livre spécifique à votre interface ;
• Les Design Patterns sont un peu passés à la trappe, c'est un peu dommage ;
• Les différentes bibliothèques à disposition ne sont pas assez fournies ;
• Le tome II laisse un peu sur sa faim (beaucoup plus court) ;
• Il ne répond pas à certaines questions récurrentes sur les forum ou listes de discussion : comment faire pour que mon application mette en place un système de plugins ? comment un objet peut-il transmettre un message à un autre en cas de changement d'état ? etc.
  

Conclusion

Même s'il n'est pas exempt de défauts, j'ai vraiment apprécié la lecture d'Au cœur de Python et je ne saurai trop vous recommander ces 2 tomes si vous maîtrisez déjà un peu le serpent. Les débutants devront peut-être s'orienter vers un livre qui les tienne un peu plus par la main.

Ce second ouvrage vous entraîne plus loin dans le monde Python en parcourant tout une série de domaines classiques (réseau, web, interface graphique avec Tkinter, base de données, ...).

Chaque sujet débute par une explication détaillée des concepts abordés, qui ainsi évitera aux débutants d'être complètement déroutés. Les exemples sont cette fois-ci beaucoup plus longs et complexes et demanderont donc beaucoup plus d'attention. Les quelques impressions d'écran (notamment pour les exemples sur Tkinter ou encore sur la création de page web) faciliteront la compréhension de la lecture sans nécessairement avoir besoin d'exécuter le code. Les sujets me semblent cependant un peu moins approfondis que dans le volume 1. L'auteur se concentre surtout sur les modules, classes et fonctions les plus couramment utilisés.

On notera toutefois quelques pages sur des bibliothèques non disponibles dans la distribution standard de Python concernant par exemple les toolkits graphiques wxPython et PyGTK ou encore la manipulation d'objet de Microsoft Office. Ceci reste tout de même très succinct mais donnera des pistes de recherche pour les programmeurs intéressés.

Ce livre reste dans la lignée de beaucoup de livres actuel sur Python : un livre généraliste présentant de manière très clair la bibliothèque standard de Python sans pour autant chercher à être le plus exhaustif possible. Si vous avez appréciez le volume 1, ce devrait toujours être le cas pour ce second volume. Si vous êtes un peu plus expérimenté, vous pouvez préférer un ouvrage plus complet tel que Python en concentré mais plus difficile à aborder.

Cette deuxième édition révisée avec les versions 2.4 et 2.5 de Python reprend entièrement (mêmes explications, exemples, ...) l'ouvrage de la première édition ajoutée de la présentation des nouveautés parues avec les versions 2.4 et 2.5, ce qui correspond à peu près à 10% du livre. Le livre est toutefois quelque peu plus aéré.

Cet ouvrage est découpé en trois parties principales à savoir les bases du langage (types de données, les exceptions, les expressions régulières ...), les principaux modules (opération sur les fichiers, les bases de données, les dates et heures, les threads, les interfaces graphiques avec Tkinter, ...) et la programmation Web et réseau (protocole http, ftp, les sockets, XML, ...)

Ce livre est plus qu'une version française de la Python Library Reference. Vous y retrouverez le descriptif de la plupart des modules et fonctions que propose Python dans sa distribution standard. Les exemples sont suffisants, toujours très courts avec des explications concises et efficaces; ce qui vous permettra de facilement mettre en pratique n'importe quelle fonction détaillée dans l'ouvrage.
Ce que j'apprécie surtout, c'est la possibilité de découvrir des fonctions/modules dont on n'aurait pas forcément soupçonné l'existence.

Bref, c'est ouvrage est à avoir à porter de main lorsque vous développez. Il n'est en revanche pas destiné à un public souhaitant avant tout apprendre le langage. Reportez vous dans ce cette optique plutôt vers un livre comme Apprendre à programmer avec Python

Critique de la première édition:
Le livre "Python en concentré" fut mon réel premier contact avec le langage Python. J'en attendais donc une certaine démystification, une explication détaillée des procédés logiques sous-jacents, et des caractéristiques originales du langage.

Je ne suis pas déçu de l'ouvrage, le chapitre 4 détaille les spécifications du langage assez clairement (structure lexicale, mots-clés, instructions, types de données, opérateurs, coercition) et on mesure bien la puissance des différentes syntaxes. Les amateurs de l'orienté objet se verront dédié le chapitre 5, qui à son tour explique les règles du modèle objet en Python (Classes, héritage, méthodes, __init__ et autres méthode spéciales).

Les autres chapitres expliquent les notions d'Exceptions, de Modules, des manipulations de chaînes et expressions régulières, et présentent de façon assez complète (à mon gout), les principes de manipulation des APIs essentielles (Persistence et SGBD, I/O, Exécution, Threads, TKinter, Réseaux, XML).

J'ai donc apprécié la lecture de l'ouvrage (et j'essaierai désormais d'utiliser Python professionnellement ;-) ), l'acheteur devra néanmoins approfondir certains aspects en créant un projet autodidactique et implémenter les différents exemples pour se familiariser avec l'outil.
Il est préférable d'avoir des notions de programmation pour acquérir ce livre.

Cette critique se rapporte à la deuxième édition.

Une fois qu'on a appris à programmer avec Python, on se retrouve face à la quantité de bibliothèques fournies en standard - je ne parle même pas des autres -. Ce livre en aborde quelques-unes.

Avant de parler du contenu, il faut noter que cette édition date, on parle dans le livre de Python 1.5 alors qu'on est à la 2.5, donc il y a eu des évolutions, et j'imagine qu'il y a eu de réelles avancées dans le domaine du multi-processus, puisque le livre n'arrête pas de remarquer les différences entre les versions Windows et Linux...

N'empêche, la première partie est assez complète - malgré les améliorations qui ont dû se greffer sur la bibliothèque standard - et on voit les différentes solutions pour faire plusieurs process, plusieurs threads, des pipes pour communiquer, ... Tout cela est relativement clair.

La deuxième partie est consacrée à Tkinter, partie que j'ai plutôt zappée car indiquant d'aller voir la doc de Tk pour plus d'approfondissement, et cette bibliothèque n'est pas ma préférée, loin s'en faut, pour faire du graphisme.

Une partie complète est consacrée au réseau, et plus particulièrement la création d'un serveur orienté web, avec l'utilisation des différents protocoles, des différents sockets de la bibliothèque standard, c'est touffu, mais très intéressant.

Enfin, l'avant-dernière partie regroupe tout ce qui n'a pas pu être mis dans les autres parties, donc la persistence des données, intéressant dans certains cas, la création de structures de données particulières, mais je serai plutôt enclin à conseiller de chercher une autre bibliothèque pour cela que faire tout soi-même, et enfin une partie sur le parsing de texte.

La dernière partie se consacre à l'intégration avec le C/C++ grâce à SWIG, ce qui permet de faire une bonne introduction à ce logiciel, même s'il faudra lire sa doc pour comprendre mieux.

Quoiqu'il en soit, ce livre est indispensable pour ceux qui veulent utiliser les threads, le réseau, pour le reste, il fait une très bonne introduction, qu'il faudra donc compléter.

Ce livre propose plus de 200 Question/Réponses réparties sur une douzaine de thèmes. Pour chaque question, vous retrouverez un ou plusieurs codes sources suivi d'une longue discussion explicative permettant de plus d'approfondir le sujet. Ces Questions/Réponses représentent une compilation effectuée depuis le site Internet http://code.activestate.com/recipes/langs/python/

Les thèmes balayés étant assez vaste, vous risquez donc de retrouver des thèmes qui ne vous préocuppent pas. Ainsi une petite partie des codes sources peuvent directement vous intéresser dans un premier temps. En revanche, pour chaque thème, les codes sources allant parfois du très court (une simple recherche de la fonction utile dans la Python Librairie Reference suffirait presque pour obtenir une réponse satisfaisante) au plus compliqué (une cinquantaine de lignes), ce livre est plus destiné au jeune développeur Python maîtrisant tout de même les bases du langage. Ainsi, il vous permettra aussi d'aborder plus sereinement des thèmes qui vous intéressent mais qui vous sont néanmoins inconnus en vous fournissant des réponses à des questions classiques pour débuter sur sujet particulier ou bien des notions que vous ne connaissiez ou ne maîtrisiez pas (le chapitre sur les Descripteurs, décorateurs et métaclasses par exemple pour moi).

Ce que j'apprécie particulièrement dans ce livre n'est pas tant le code source en lui-même (étant capable de trouver sans trop de difficultés une solution adaptée aux problèmes que je rencontre) mais plutôt la discussion qui suit à chaque fois. Ces discussions permettent de réfléchir aux différentes pistes pour solutionner un problème (celles auxquelles nous pensons ne sont pas toujours les plus efficaces, optimisées, les moins gourmandes en mémoire ou encore les plus pythoniques), aux différentes notions qui en résultent et aux astuces que l'on peut découvrir.

Le seul regret est que cette traduction ne présente que 12 chapitres sur les 20 que contient l'édition originale pour un prix équivalent.
Je conseille donc ce livre aussi bien aux personnes développant dans un contexte assez large et aux personnes souhaitons améliorer leur culture pythonique.

Quand on veut utiliser une GUI avec Python, on a le choix. Entre TkInter, wxPython, pyQt, pyGames, ... on a de quoi faire. La grande question qui reste est comment choisir, sur quels critères. C'est là où wxPython a un avantage certain : sur TkInter par sa "beauté", sur pyGame car basé sur un toolkit objet, et enfin sur pyQt parce qu'il y a un livre !

Et ce livre est très bien fait. On commence par une entrée qui résume en gros le livre. Si on comprend cette partie, on peut survoler presque toutes les autres parties lors de la compréhension du fonctionnement, lorsqu'il faudra regarder des spécificités, il faudra s'attarder pour observer, mais c'est normal.

Les parties suivantes explorent donc ce qui a été exposé rapidement en première partie. On aurait peut-être aimé lire que ce qu'on apprend a déjà été exposé précédemment en version simplifiée, mais ce n'est pas indispensable. On y voit tout ce qu'il faut savoir pour créer une interface rapidement.

La dernière partie est plus hétéroclyte, avec une introduction à trois composants un peu particuliers permettant d'afficher certains résultats et d'interagir avec, du Model-View-Controller en quelque sorte. Ensuite, on aborde le widget HTML puis très rapidement le multithreading. On aurait apprécié voir un code un peu plus complexe pour montrer les interactions en multithreading, mais bon...

Je suis resté sur ma faim, j'aurai apprécié une introduction au notebook et surtout à wxOGL, puisque l'implémentation est native Python, et que la doc associée est manquante... Mais malgré cela, c'est un très bon livre et le seul à jour sur un toolkit graphique pour Python. Enfin, à ce jour.

Voilà le livre que j'attendais depuis longtemps. Ce livre m'a complètement réconcilié avec la bibliothèque wxPython. Le livre est en anglais mais il est d'une lecture vraiment très aisée même pour quelqu'un peu doué avec cette langue.

Vous entrerez très facilement avec les 2 premiers chapitres dans la conception des IHM wxPython, chapitres qui vous apporteront les bases fondamentales à toute application qui s'appuie sur wxPython. Cette partie se poursuit par deux chapitres importants avec les évènements que vos applications devront gérer et un autre qui vous donnera de très bon conseils sur l'écriture de vos IHM pour que celles-ci restent maintenables et modifiables dans le long terme.

Dans la deuxième partie, on vous expliquera comment insérer dans vos applications la plupart des widgets basiques. Pour chacun d'eux, vous trouverez une multitude d'exemples de codes source entièrement fonctionnels en général assez courts (une vingtaine de lignes) et toujours accompagnés d'un text explicatif conséquent qui en plus détaille chaque point référencé dans le code source. Ce chapitre sera aussi parsemé de nombreux tableaux récapitulant les constantes utiles pour les paramètres et les évènements caractérisant de vos widgets. Vous en trouverez également d'autres qui décrivent les méthodes des widgets les plus utilisées. Les chapitres suivants vous apporteront de longues explications sur la construction des dialogues et des menus wxPython et sur la manipulation des sizers et des images.

Enfin dans la troisième partie, vous irez encore plus loin avec des chapitres entièrement consacrés aux widgets tels que les contrôles grid ou tree. Bref, pour ceux qui pensaient comme moi que les exemples téléchargeables sur le site officiel de wxPython ne se suffisaient pas à eux-mêmes pour entrer complètement dans cette bibliothèque, vous ne serez pas déçus par ce livre. Toutefois, l'utilisation de ces exemples (ainsi que de la documentation de l'API wxPython) est ensuite aussi vivement recommandée lorsqu'on souhaite avoir rapidement un exemple de fonctionnalités non forcément présentées dans l'ouvrage. Mais vous vous y retrouverez beaucoup plus facilement et rapidement qu'avant.

En conclusion, si vous voulez créer des interfaces graphiques professionnelles mais que vous hésitiez encore entre les différentes bibliothèques à votre disposition, sachez que vous trouverez votre bonheur grâce à ce livre - en tout cas, depuis que j'ai ce livre, j'envisage (et j'ai même commencé) de migrer mes IHMs Delphi en wxPython.

Ce livre est une mise à jour de "Apprendre à programmer avec Python" adapté à Python 3.

Gérard Swinnen démontre avec ce livre un sens de la pédagogie incroyable. Très axé débutant, il y explique les bases de la programmation de manière claire et précise. Chaque chapitre propose de petits exercices simples et très bien ciblés, ce qui donne envie de jouer avec Python et captive le lecteur.
Les derniers chapitres vous présenteront des notions avancées comme le web, les bases de données, les réseaux et le multithreading.

Si vous êtes déjà très expérimentés dans un autre langage, ce livre n'est pas adapté et passez votre chemin ; il est vraiment destiné aux débutants ou peut servir d'excellent support de cours.

Mon seul regret concerne les parties Tkinter. J'aurais préféré une API telle que PyQt plus moderne.