Soutenez-nous

PythonConsultez tous les livres

Dernière mise à jour : 29 juillet 2013 

precedentsommairesuivant
  1. Le Python en bref
  2. Apprendre à programmer avec Python 3 - Avec plus de 50 pages de corigés d'exercices !
  3. The Definitive Guide to Jython
  4. Programming Python
  5. Rapid GUI Programming With Python and Qt - The Definitive Guide to Pyqt Programming
  6. Beginning Python Visualization - Crafting Visual Transformation Scripts
  7. IronPython in Action
  8. Python - Les Fondamentaux du langage - La Programmation pour les scientifiques
  9. Apprendre à programmer avec Python
  10. Au coeur de Python - volume 2
  11. Au coeur de Python - volume 1
  12. Python en Concentré - Manuel de référence
  13. Programming Python
  14. Python par l'exemple
  15. wxPython In Action
  16. Python précis et concis
couverture du livre Le Python en bref

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Le Python en bref

de Alexandre GALODE
Public visé : débutant

Résumé de l'éditeur

Pour l'auteur, l'apprentissage d'un langage informatique passe d'abord par une présentation succincte des diverses commandes et de leurs fonctions/utilisations, puis par une phase de pratique visant à apprendre à les maîtriser.

Cette vision de l'apprentissage a abouti à l'écriture de ce condensé PYTHON, conçu à la fois comme une aide à l'apprentissage, mais également comme un aide-mémoire du langage.

Langage interprété multifonctions, PYTHON peut apparaître comme un véritable couteau suisse capable de servir à réaliser aussi bien du scripting sur serveur que des logiciels avec interface graphique.

Ainsi, après une brève présentation des principales différences entre langage compilé et langage interprété puis du principe de programmation objet, l'auteur vous présentera le langage de manière simplifiée.

Chaque explication est documentée d'un exemple visant à créer une mise en situation et à améliorer la compréhension.

8 commentaires Donner une note à l'article (5)

423 pages, 1re édition, 15 avril 2013 

Édition : ILV-Edition

ISBN10 : 2352096588

ISBN13 : 978-2-35209-658-0

ILV-Edition : 37,00 € seulement

Commandez sur www.amazon.fr :

37,00 € TTC (prix éditeur 37,00 € TTC) livraison gratuite !

Sommaire

  • Présentation
  • La Programmation Orientée Objet
  • Le Langage Python
  • Modules complémentaires
  • Les Interfaces graphiques
  • La 3D
  • Gestion d'un projet
  • Déploiement
  • Ressources
  • Annexes

 
Critique du livre par la rédaction Nicolas Vallée (gorgonite) le 28 juillet 2013 

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.

 
couverture du livre Apprendre à programmer avec Python 3

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Apprendre à programmer avec Python 3

Avec plus de 50 pages de corigés d'exercices !

de Gérard Swinnen
Public visé : Debutant

Résumé de l'éditeur

Quoi de mieux pour apprendre la programmation qu'un langage moderne et élégant tel que Python, aussi performant pour le développement d'applications web que pour la réalisation de scripts système ou l'analyse de fichiers textuels ?

Un support de cours réputé et adopté par de nombreux enseignants, avec 50 pages d'exercices corrigés
Reconnu et utilisé par les enseignants de nombreuses écoles et IUT, complété d'exercices accompagnés de leurs corrigés, cet ouvrage original et érudit est une référence sur tous les fondamentaux de la programmation : choix d'une structure de données, paramétrage, modularité, orientation objet et héritage, conception d'interface, multithreading et gestion d'événements, protocoles de communication et gestion réseau, bases de données... jusqu'à la désormais indispensable norme Unicode (le format UTF-8). Cette nouvelle édition détaille notamment la réalisation avec Python 3 d'une application web interactive et autonome, intégrant la gestion d'une base de données SQLite.

À qui s'adresse ce livre ?
* Aux étudiants en BTS et IUT Informatique et à leurs enseignants ;
* A tous les autodidactes férus de programmation qui veulent découvrir le langage Python.

410 pages, 2e édition, 2 février 2012 

Édition : Eyrolles

ISBN10 : 2212127081

ISBN13 : 9782212127089

Eyrolles : 32 € TTC seulement

Commandez sur www.amazon.fr :

30.40 € TTC seulement (au lieu de 32  € TTC : prix éditeur) livraison gratuite !
  • Chapitre 1 : A l'école des sorciers
  • Chapitre 2 : Premiers pas
  • Chapitre 3 : Contrôle du flux d'exécution
  • Chapitre 4 : Instructions répétitives
  • Chapitre 5 : Principaux types de données
  • Chapitre 6 : Fonctions prédéfinies
  • Chapitre 7 : Fonctions originales
  • Chapitre 8 : Utilisation de fenêtres et de graphismes
  • Chapitre 9 : Manipuler des fichiers
  • Chapitre 10 : Approfondir les structures de données
  • Chapitre 11 : Classes, objets, attributs
  • Chapitre 12 : Classes, méthodes, héritage
  • Chapitre 13 : Classes et interfaces graphiques
  • Chapitre 14 : Et pour quelques widgets de plus...
  • Chapitre 15 : Analyse de programmes concrets
  • Chapitre 16 : Gestion d'une base de données
  • Chapitre 17 : Applications web
  • Chapitre 18 : Communications à travers un réseau et multithreading
  • Annexe A : Installation de Python
  • Annexe B : Solutions des exercices

 
Critique du livre par la rédaction verdvaine yan le 13 juin 2012 

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.

 
couverture du livre The Definitive Guide to Jython

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

The Definitive Guide to Jython

de Josh Juneau
Public visé : débutant, intermédiaire

Résumé de l'éditeur

Jython is an open source implementation of the high-level, dynamic, object-oriented scripting language Python seamlessly integrated with the Java platform. The predecessor to Jython, JPython, is certified as 100% Pure Java. Jython is freely available for both commercial and noncommercial use and is distributed with source code. Jython is complementary to Java.
The Definitive Guide to Jython, written by the official Jython team leads, covers the latest Jython 2.5 (or 2.5.x) from the basics to the advanced features. This book begins with a brief introduction to the language and then journeys through Jython's different features and uses.
The Definitive Guide to Jython is organized for beginners as well as advanced users of the language. The book provides a general overview of the Jython language itself, but it also includes intermediate and advanced topics regarding database, web, and GUI applications; Web services/SOA; and integration, concurrency, and parallelism, to name a few.

544 pages, 1re édition, 22 février 2010 

Édition : APress

ISBN10 : 1430225270

ISBN13 : 9781430225270

Commandez sur www.amazon.fr :

34.04 € TTC (prix éditeur 34.04 € TTC) livraison gratuite !

Part I: Jython Basics: Learning the Language

  • Chapter 1: Language and Syntax 3
  • Chapter 2: Data Types and Referencing
  • Chapter 3: Operators, Expressions, and Program Flow
  • Chapter 4: Defining Functions and Using Built-ins
  • Chapter 5: Input and Output
  • Chapter 6: Object-Oriented Jython
  • Chapter 7: Exception Handling and Debugging
  • Chapter 8: Modules and Packages for Code Reuse

Part II: Using the Language

  • Chapter 9: Scripting With Jython
  • Chapter 10: Jython and Java Integration
  • Chapter 11: Using Jython in an IDE
  • Chapter 12: Databases and Jython: Object Relational Mapping and Using JDBC

Part III: Developing Applications with Jython

  • Chapter 13: Simple Web Applications
  • Chapter 14: Web Applications With Django
  • Chapter 15: Introduction to Pylons
  • Chapter 16: GUI Applications
  • Chapter 17: Deployment Targets

Part IV:Strategy and Technique

  • Chapter 18: Testing and Continuous Integration
  • Chapter 19: Concurrency

Part V: Appendicies and Attribution

  • Appendix A: Using Other Tools with Jython
  • Appendix B: Jython Cookbook
  • Appendix C: Built-in Functions

 
Critique du livre par Pierre Thibault le 19 août 2010 

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.

 
couverture du livre Programming Python

Note 4.0drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

Programming Python

de Mark Lutz
Public visé : débutant à intermédiaire

Résumé de l'éditeur

If you've mastered Python's fundamentals, you're ready to start using it to get real work done. Programming Python will show you how, with in-depth tutorials on the language's primary application domains: system administration, GUIs, and the Web. You'll also explore how Python is used in databases, networking, front-end scripting layers, text processing, and more. This book focuses on commonly used tools and libraries to give you a comprehensive understanding of Python's many roles in practical, real-world programming.

You'll learn language syntax and programming techniques in a clear and concise manner, with lots of examples that illustrate both correct usage and common idioms. Completely updated for version 3.x, Programming Python also delves into the language as a software development tool, with many code examples scaled specifically for that purpose.

Topics include:
  • Quick Python tour: Build a simple demo that includes data representation, object-oriented programming, object persistence, GUIs, and website basics
  • System programming: Explore system interface tools and techniques for command-line scripting, processing files and folders, running programs in parallel, and more
  • GUI programming: Learn to use Python's tkinter widget library
  • Internet programming: Access client-side network protocols and email tools, use CGI scripts, and learn website implementation techniques
  • More ways to apply Python: Implement data structures, parse text-based information, interface with databases, and extend and embed Python
1632 pages, 1er janvier 2011 

Édition : O'Reilly

ISBN10 : 0596158106

ISBN13 : 9780596158101

Commandez sur www.amazon.fr :

47,18 € TTC (prix éditeur 50,60 € TTC) livraison gratuite !

The Beginning

  • Chapter 1: A Sneak Preview

    • "Programming Python: The Short Story"
    • The Task
    • Step 1: Representing Records
    • Step 2: Storing Records Persistently
    • Step 3: Stepping Up to OOP
    • Step 4: Adding Console Interaction
    • Step 5: Adding a GUI
    • Step 6: Adding a Web Interface
    • The End of the Demo

System Programming

  • Chapter 2: System Tools

    • "The os.path to Knowledge"
    • System Scripting Overview
    • Introducing the sys Module
    • Introducing the os Module
  • Chapter 3: Script Execution Context

    • "I'd Like to Have an Argument, Please"
    • Current Working Directory
    • Command-Line Arguments
    • Shell Environment Variables
    • Standard Streams
  • Chapter 4: File and Directory Tools

    • "Erase Your Hard Drive in Five Easy Steps!"
    • File Tools
    • Directory Tools
  • Chapter 5: Parallel System Tools

    • "Telling the Monkeys What to Do"
    • Forking Processes
    • Threads
    • Program Exits
    • Interprocess Communication
    • The multiprocessing Module
    • Other Ways to Start Programs
    • A Portable Program-Launch Framework
    • Other System Tools Coverage
  • Chapter 6: Complete System Programs

    • "The Greps of Wrath"
    • A Quick Game of "Find the Biggest Python File"
    • Splitting and Joining Files
    • Generating Redirection Web Pages
    • A Regression Test Script
    • Copying Directory Trees
    • Comparing Directory Trees
    • Searching Directory Trees
    • Visitor: Walking Directories "++"
    • Playing Media Files
    • Automated Program Launchers (External)

GUI Programming

  • Chapter 7: Graphical User Interfaces

    • "Here's Looking at You, Kid"
    • Python GUI Development Options
    • tkinter Overview
    • Climbing the GUI Learning Curve
    • tkinter Coding Alternatives
    • Adding Buttons and Callbacks
    • Adding User-Defined Callback Handlers
    • Adding Multiple Widgets
    • Customizing Widgets with Classes
    • Reusable GUI Components with Classes
    • The End of the Tutorial
    • Python/tkinter for Tcl/Tk Converts
  • Chapter 8: A tkinter Tour, Part 1

    • "Widgets and Gadgets and GUIs, Oh My!"
    • Configuring Widget Appearance
    • Top-Level Windows
    • Dialogs
    • Binding Events
    • Message and Entry
    • Checkbutton, Radiobutton, and Scale
    • Running GUI Code Three Ways
    • Images
    • Viewing and Processing Images with PIL
  • Chapter 9: A tkinter Tour, Part 2

    • "On Today's Menu: Spam, Spam, and Spam"
    • Menus
    • Listboxes and Scrollbars
    • Text
    • Canvas
    • Grids
    • Time Tools, Threads, and Animation
    • The End of the Tour
  • Chapter 10: GUI Coding Techniques

    • "Building a Better Mousetrap"
    • GuiMixin: Common Tool Mixin Classes
    • GuiMaker: Automating Menus and Toolbars
    • ShellGui: GUIs for Command-Line Tools
    • GuiStreams: Redirecting Streams to Widgets
    • Reloading Callback Handlers Dynamically
    • Wrapping Up Top-Level Window Interfaces
    • GUIs, Threads, and Queues
    • More Ways to Add GUIs to Non-GUI Code
    • The PyDemos and PyGadgets Launchers
  • Chapter 11: Complete GUI Programs

    • "Python, Open Source, and Camaros"
    • PyEdit: A Text Editor Program/Object
    • PyPhoto: An Image Viewer and Resizer
    • PyView: An Image and Notes Slideshow
    • PyDraw: Painting and Moving Graphics
    • PyClock: An Analog/Digital Clock Widget
    • PyToe: A Tic-Tac-Toe Game Widget
    • Where to Go from Here

Internet Programming

  • Chapter 12: Network Scripting

    • "Tune In, Log On, and Drop Out"
    • Python Internet Development Options
    • Plumbing the Internet
    • Socket Programming
    • Handling Multiple Clients
    • Making Sockets Look Like Files and Streams
    • A Simple Python File Server
  • Chapter 13: Client-Side Scripting

    • FTP: Transferring Files over the Net
    • Transferring Files with ftplib
    • Transferring Directories with ftplib
    • Transferring Directory Trees with ftplib
    • Processing Internet Email
    • POP: Fetching Email
    • SMTP: Sending Email
    • email: Parsing and Composing Mail Content
    • A Console-Based Email Client
    • The mailtools Utility Package
    • NNTP: Accessing Newsgroups
    • HTTP: Accessing Websites
    • The urllib Package Revisited
    • Other Client-Side Scripting Options
  • Chapter 14: The PyMailGUI Client

    • "Use the Source, Luke"
    • Major PyMailGUI Changes
    • A PyMailGUI Demo
    • PyMailGUI Implementation
    • Ideas for Improvement
  • Chapter 15: Server-Side Scripting

    • "Oh, What a Tangled Web We Weave"
    • What's a Server-Side CGI Script?
    • Running Server-Side Examples
    • Climbing the CGI Learning Curve
    • Saving State Information in CGI Scripts
    • The Hello World Selector
    • Refactoring Code for Maintainability
    • More on HTML and URL Escapes
    • Transferring Files to Clients and Servers
  • Chapter 16: The PyMailCGI Server

    • "Things to Do When Visiting Chicago"
    • The PyMailCGI Website
    • The Root Page
    • Sending Mail by SMTP
    • Reading POP Email
    • Processing Fetched Mail
    • Utility Modules
    • Web Scripting Trade-Offs

Tools and Techniques

  • Chapter 17: Databases and Persistence

    • "Give Me an Order of Persistence, but Hold the Pickles"
    • Persistence Options in Python
    • DBM Files
    • Pickled Objects
    • Shelve Files
    • The ZODB Object-Oriented Database
    • SQL Database Interfaces
    • ORMs: Object Relational Mappers
    • PyForm: A Persistent Object Viewer (External)
  • Chapter 18: Data Structures

    • "Roses Are Red, Violets Are Blue; Lists Are Mutable, and So Is Set Foo"
    • Implementing Stacks
    • Implementing Sets
    • Subclassing Built-in Types
    • Binary Search Trees
    • Graph Searching
    • Permuting Sequences
    • Reversing and Sorting Sequences
    • PyTree: A Generic Tree Object Viewer
  • Chapter 19: Text and Language

    • "See Jack Hack. Hack, Jack, Hack"
    • Strategies for Processing Text in Python
    • String Method Utilities
    • Regular Expression Pattern Matching
    • XML and HTML Parsing
    • Advanced Language Tools
    • Custom Language Parsers
    • PyCalc: A Calculator Program/Object
  • Chapter 20: Python/C Integration

    • "I Am Lost at C"
    • Extending Python in C: Overview
    • A Simple C Extension Module
    • The SWIG Integration Code Generator
    • Wrapping C Environment Calls
    • Wrapping C++ Classes with SWIG
    • Other Extending Tools
    • Embedding Python in C: Overview
    • Basic Embedding Techniques
    • Registering Callback Handler Objects
    • Using Python Classes in C
    • Other Integration Topics

The End

  • Chapter 21: Conclusion: Python and the Development Cycle

    • "Something's Wrong with the Way We Program Computers"
    • The "Gilligan Factor"
    • Doing the Right Thing
    • Enter Python
    • But What About That Bottleneck?
    • On Sinking the Titanic
    • So What's "Python: The Sequel"?
    • In the Final Analysis.

 
Critique du livre par la rédaction Thibaut Cuvelier le 6 mars 2011 

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).

Vous avez lu ce livre ? Qu'en pensez-vous ? Commentez Donner une note à l'article (5)

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).

 
couverture du livre Rapid GUI Programming With Python and Qt

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Rapid GUI Programming With Python and Qt

The Definitive Guide to Pyqt Programming

de Mark Summerfield
Public visé : débutant, intermédiaire, expert

Résumé de l'éditeur

Que vous soyez en train de créer des prototypes d'interfaces graphiques ou des applications entièrement multiplateforme avec un aspect natif pour chaque système, PyQt 4 est votre solution la plus rapide, la plus simple et la plus puissante. Mark Summerfield, expert Qt, a écrit sans conteste le meilleur guide des bonnes pratiques pour le développement avec PyQt 4.

Avec Rapid GUI Programming with Python and Qt vous allez apprendre comment créer des applications d'interfaces graphiques efficaces qui s'exécutent sous la majeure partie des systèmes d'exploitation tels que Windows, Mac OS X, Linux et de nombreuses versions d'Unix, en utilisant le même code source pour tous. Summerfield introduit systématiquement chaque technique de développement d'interfaces graphiques : des boîtes de dialogue et des fenêtres pour gérer des données ; des événements d'impression ; et plus encore. À travers les exemples réels de ce livre, vous allez découvrir une approche complètement nouvelle de la programmation basée sur PyQt 4, ainsi que le traitement de nombreux sujets, d'un moteur de texte riche écrit en PyQt 4, à la programmation avancée de modèles/vues et de graphiques/vues. Tous les concepts clés sont agrémentés d'exemples réels, téléchargeables et testés sous Windows, Mac OS X et Linux avec Python 2.5, Qt 4.2 et PyQt 4.2, et sur Windows et Linux avec Qt 4.3 et PyQt 4.3.

Sujets traités :

  • bases de Python basiques pour tous les développeurs PyQt : types de données, structures de données, structures de contrôle, classes, modules et plus encore ;
  • techniques principales de programmation d'interfaces graphiques avec PyQt : boîtes de dialogue, fenêtres principales et formats de fichiers personnalisés ;
  • utilisation de Qt Designer pour créer des interfaces utilisateurs et pour implémenter ainsi que tester des boîtes de dialogue, des événements, le presse-papier et le glisser/déposer ;
  • construction de widgets personnalisés : feuilles de style pour widgets, widgets composés, sous-classes et plus encore ;
  • profiter du maximum de la nouvelle architecture graphiques/vues de Qt 4.2 ;
  • connexion à des bases de données, exécution de requêtes et utilisation des formulaires et des tableaux ;
  • programmation avancée avec le modèle/vue : vues personnalisées, générique delegates et plus encore ;
  • implémentation d'une aide en ligne, traduction d'applications, et utilisation des possibilités du réseau et du multi-thread de PyQt.
648 pages, 1re édition, 18 octobre 2007 

Édition : Prentice Hall

ISBN10 : 0132354187

Commandez sur www.amazon.fr :

41,87 € TTC (prix éditeur 45,04 € TTC) livraison gratuite !
  1. Python Programming
    1. Data Types and Data Structures
    2. Control Structures
    3. Classes and Modules
  2. Basic GUI Programming
    1. Introduction to GUI Programming
    2. Dialogs
    3. Main Windows
    4. Using Qt Designer
    5. Custom File Formats
  3. Intermediate GUI Programming
    1. Layouts and Multiple Documents
    2. Events, the Clipboard, and Drag and Drop
    3. Custom Widgets
    4. Graphics (this chapter is devoted to the graphics view architecture introduced with Qt 4.2)
    5. Rich Text
    6. Model/View Programming
    7. Databases
  4. Advanced GUI Programming
    1. Advanced Model/View Programming
    2. Internationalization
    3. Networking
    4. Multithreading
  5. Appendix A: Installing Python, PyQt, and the Qt Libraries on Windows, Mac OS X, and X11-based Unices including Linux
  6. Appendix B: Selected PyQt Widgets
  7. Appendix C: Selected PyQt Class Hierarchies
  8. Index

 
Critique du livre par Christophe Kibleur le 1er novembre 2007 

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.

 
couverture du livre Beginning Python Visualization

Note 4.5drapeau
Détails du livre
Critiques (1)
 
 

Beginning Python Visualization

Crafting Visual Transformation Scripts

de S. Vaingast
Public visé : Débutant, intermédiaire

Résumé de l'éditeur

We are visual animals. But before we can see the world in its true splendor, our brains, just like our computers, have to sort and organize raw data, and then transform that data to produce new images of the world. Beginning Python Visualization: Crafting Visual Transformation Scripts talks about turning many types of small data sources into useful visual data. And you will learn Python as part of the bargain.

384 pages, 1re édition, 1er mars 2009 

Édition : APress

ISBN10 : 1430218436

ISBN13 : 9781430218432

www.apress.com : 42.99 $ seulement

Commandez sur www.amazon.fr :

34,87 € TTC (prix éditeur 36,11 $) livraison gratuite !
Critique du livre par la rédaction Matthieu Brucher le 1er septembre 2009 

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

 
couverture du livre IronPython in Action

Note 4.0drapeau
Détails du livre
Critiques (1)
 
 

IronPython in Action

de Michael J. Foord et Christian Muirhead
Public visé : débutant

Résumé de l'éditeur

En 2005, Microsoft a annoncé tranquillement une initiative pour développer des langages dynamiques sur la plateforme .Net. Le point de départ fut une implémentation .Net de Python appelée IronPython. Après quelques années, celui-ci est prêt pour une utilisation réelle. Elle allie la simplicité, l'élégance et le dynamisme de Python associé à la puissance de la plateforme .Net.

IronPython in Action offre une introduction accessible et directe à une nouvelle approche proposée par Microsoft à son framework .Net. Python est ici un langage principal, complètement intégré à l'environnement .Net avec Visual Studio ainsi que la version Open Source Mono. Vous apprendrez comment IronPython peut être intégré comme un langage de script prêt à l'utilisation pour C# ou VB.Net, pour écrire des applications complètes ou des pages Web avec ASP. Même mieux, vous verrez comment IronPython fonctionne dans Silverlight dans le cadre de la programmation web côté client.

496 pages, 1re édition, 1er mars 2009 

Édition : Manning

ISBN10 : 1933988339

www.manning.com : 44,99 $ seulement

Critique du livre par la rédaction Matthieu Brucher le 1er mai 2009 

IronPython est le premier langage dynamique qui ait été développé pour .Net. A la base, .Net n'était pas prévu pour ce type de langage. On voit au fil du livre qu'il est souvent nécessaire de faire appel à des astuces pour vraiment tirer partie des langages statiques et dynamiques de .Net.

Le livre commence par une introduction générale à Python. Une revue rapide du langage lui-même est suivie par l'utilisation des différents assemblies disponibles dans la plateforme .Net. Cette première partie permet d'être à l'aise avec IronPython.

La partie suivante est dédiée aux possibilités offertes par IronPython, de par le langage et son affiliation à .Net. Les auteurs passent des modules standard Python aux modules .Net (ce qui peut être déboussolant, pourquoi utiliser les uns et pas les autres ?) selon ce qu'on cherche à faire. A cause de .Net, une grande partie est dédiée à XML car c'est une partie permettant de simplifier l'écriture des interfaces graphiques. Plusieurs patterns usuels sont aussi présentés sous l'approche .Net.

La troisième partie part de l'interface de référence WPF, avec plusieurs manières de l'utiliser. Un début de pont depuis C# est aussi proposé. Par la suite, on aborde la partie administration avec WMI. Je dois dire que de mon point de vue, c'est la partie la plus bizarre. WMI a son propre langage qui ne ressemble en rien à Python ou C#. En plus, on ajoute le langage spécifique à PowerShell (qui vient un peu comme un cheveu sur la soupe). Il y a un livre dédié, donc le seul accent est mis sur la communication entre IronPython et PowerShell. Soit donc deux nouveaux langages dans un seul chapitre.

IronPython est un langage .Net, donc il est possible de faire de l'ASP avec. Un chapitre est consacré à cette approche, chapitre bien écrit mais qui nécessite d'avoir en parallèle l'exemple décrit sans quoi on se perd un peu. En continuant le web, on passe aux web services et aux bases de données qui sont regroupées sous un seul chapeau. La base des outils SQL nécessaires est abordée, ainsi que les protocoles de web services basiques. En revanche, il y a quelques erreurs, comme SOAP qui n'est pas qu'utilisé avec des requêtes POST en HTTP, mais bien aussi avec des requêtes GET et sur d'autres transports. Enfin, l'utilisation d'IronPython avec Silverlight est abordé. Les interactions avec d'autres langages ainsi qu'avec la page affichée permettent de développer des applications légères efficaces.

Dans tout le livre, on a vu des bases de communication avec les autres langages .Net. C'est dans la dernière partie qu'on voit les bons moyens d'intégrer des assemblies .Net dans IronPython et inversement. Comme je l'ai dit au départ, l'intégration n'est malheureusement pas tout à fait aisée, et les différentes techniques ajoutent un coût d'écriture certain. Au moins, elles sont exposées dans ce livre, en attendant .Net 4.0.

Pour conclure, ceux qui ont besoin d'un langage dynamique (pour scripter une application, par exemple) peuvent se pencher sur IronPython, le premier langage dynamique proposé par la plateforme .Net, compatible avec le langage Python version 2.5. et donc acheter ce livre pour maîtriser cette implémentation.

IronPython is the first dynamic language developed for the .Net plateform. At first, .Net didn't support this kind of language. This is something that keeps on coming back througout the book: you have to use some additional tricks to unleash the power of .Net dynamic and static languages.

The book starts with a general introduction to IronPython. A quick review of the language itself is followed by the use of the .Net assemblies. At the end of this part, one is comfortable enough to do some small IronPython programs.

The next part is dedicated to what IronPython offers thanks to Python and to its affiliation to .Net. The authors go through standard Python (battery included) and the somewhat associated .Net assemblies (some arguments on using one or the other could have been a big plus to the explanations), depending on what must be done. Because or (or thanks to) .Net, several pages are dedicated to XML, as it is needed to simplify the description of UIs. Also several useful designed patterns are presented with the .Net approach.

The next part starts with WPF, the official graphical interface, with several ways of using it (bridge from C#, XAML, ...). Then WMI (used for system administration) is handled, but from my point of view, it is the weirdest part. WMI has its own language which does not seem like C# or Python. Besides, PowerShell, presented as well as a way of doing system administration, has its own language. There is a book dedicated to PowerShell, so only the communication between IronPython and PowerShell is handled. So two additional languages in this chapter, perhaps too many (they are limited to this chapter).

IronPython is a .Net language, so it is possible to do ASP with it. A chapter deals with this approach, chapter well written but it needs to follow the associated example in your favorite IDE if you want to follow what's happening. Web means also web services and databases, handled in one chapter. The basis of SQL tools addressed, as well as basic webservces (mainly REST). I have to say that there are some mistakes there, as SOAP is not only used with POST HTTP requests but also with GET requests (it can be seen in the official w3c specification) and also with other transport protocols than HTTP. Perhaps these are .Net implementation's limitation, in which case it should have been mentioned. Finally Silverlight integration allows developping light clients that can interact with other langages as well as the web page.

Throughout the book, complete interaction with other .Net languages was not addressed. It is the goal of the last part to show how assemblies can be used in IronPython and how IronPython scripts can be used from .Net static languages. As I've said, the interaction does not go completely smoothly, there are several solutions to accomplish it. At least, the book does not only speak about the upcoming .Net 4.0 that will help this interaction.

As a conclusion, those who need a dynamic language (to script an application) can go for IronPython, th first dynamic language for the .Net framework, compatible with the langage Python 2.5, and in that case, go for this book that will help you for anything.

 
couverture du livre Python

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Python

Les Fondamentaux du langage - La Programmation pour les scientifiques

de Matthieu Brucher
Public visé : Intermédiaire - Avancé

Résumé de l'éditeur

L'objectif de ce livre sur Python est de fournir les fondamentaux de ce langage à des scientifiques habitués à d'autres langages comme le Fortran, le C, Matlab... et aussi à des informaticiens qui travaillent dans le milieu scientifique. Des connaissances élémentaires sur la programmation sont nécessaires au lecteur pour tirer le meilleur parti de ce livre.

L'auteur détaille les bases du langage puis présente, avec des exemples, des outils que les scientifiques n'ont pas l'habitude d'utiliser (sauvegarde des données, parallélisme, XML...). Ensuite, l'auteur décrit le module matriciel Numpy (comment manipuler des tableaux, la syntaxe et les fonctions usuelles), un "catalogue" des outils proposés par Scipy (optimisation numérique, statistiques, traitement du signal...) ainsi que des fonctionnalités graphiques indispensables pour les rapports ou les publications. La dernière partie présente les outils pour communiquer avec le C ou le C++.

400 pages, 1er janvier 2008 

Édition : Editions ENI

ISBN10 : 2746040883

www.editions-eni.fr : 25.78 € TTC seulement seulement (au lieu de 27.14 € TTC : prix public)

Commandez sur www.amazon.fr :

25.78 € TTC seulement (au lieu de 27.14  € TTC : prix éditeur) livraison gratuite !
  • Introduction et origines
  • Le langage Python
  • Les modules indispensables de la bibliothèque standard
  • D'autres modules de la bibliothèque standard
  • Numpy : une bibliothèque mathématique pour Python
  • Scipy : la boîte à outils scientifiques
  • Graphiques 2D avec Matplotlib
  • Interface C/C++ avec Python

 
Critique du livre par la rédaction Guillaume Duriaud le 17 avril 2008 

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écilite de plus d'être le pionner dans l'écriture d'un livre en français consacré à ce domaine.

Critique du livre par la rédaction Alp Mestan le 13 novembre 2008 

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.

 
couverture du livre Apprendre à programmer avec Python

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Apprendre à programmer avec Python

de Gérard Swinnen
Public visé : Débutant

Résumé de l'éditeur

Peut-être pensiez-vous que la programmation était réservée aux programmeurs ? Il s'agit d'une activité complexe, bien sûr, qui vous demandera sans aucun doute quelques efforts. Mais c'est aussi une occupation passionnante, qui peut vous aider dans votre quotidien et dont il est faux de croire qu'elle est réservée à une élite de professionnels. Nous vous proposons une démarche pédagogique qui a fait ses preuves et un langage moderne, Python, plébiscité par de nombreux enseignants et professionnels. Gérard Swinnen cherche avant tout à susciter l'intérêt du lecteur. Il propose d'emblée au lecteur de réaliser quelques applications simples, mais attrayantes, qui s'appuient sur des concepts importants : types de données, variables, instructions de contrôle de flux, fonctions et boucles. Il n'est pas nécessaire en effet de connaître toute la théorie pour commencer à programmer. Après cette première mise en appétit, il passe à la mise en ?uvre d'applications graphiques et approfondit les structures de données, la gestion des fichiers, les techniques de parcours des séquences, tout en amenant le lecteur à utiliser de plus en plus souvent le concept informatique d'objet. Dans un deuxième temps, il explique comment construire soi-même de tels objets à l'aide de classes, ce qui constitue le fondement d'une méthodologie de programmation particulièrement efficace : la POO (Programmation Orientée Objet). Au terme de cette approche, il vous invite à confronter ces connaissances encore théoriques à l'analyse de programmes concrets, avant de passer à des projets plus ambitieux, qui répondent à des besoins réels comme le développement d'applications web, la programmation de bases de données ou encore la programmation réseau. Une telle démarche ne pouvait s'appuyer sur n'importe quel langage. Python est supporté par tous les grands systèmes d'exploitation : Windows, Mac OS, Linux et autres Unix. Il est portable, c'est-à-dire que l'utilisateur peut utiliser ses programmes sur n'importe quelle plateforme. Il est gratuit. Sa syntaxe, simple, mais néanmoins évoluée, est suffisamment rigoureuse pour enseigner les invariants de l'informatique. Python convient aussi bien à des projets simples qu'à des projets de grande envergure. Il dispose de nombreuses bibliothèques. Enfin, il est largement reconnu dans le monde professionnel et soutenu par une communauté enthousiaste et généreuse. N'ayez pas peur, lancez-vous, et apprenez à programmer avec Python !

407 pages, 28 avril 2005 

Édition : O'Reilly

ISBN10 : 2841772993

Commandez sur www.amazon.fr :

30,40 € TTC (prix éditeur 32,00 € TTC) livraison gratuite !
  • Introduction
  • 1. Penser comme un programmeur
  • 2. Premiers pas
  • 3. Contrôle du flux d'instructions
  • 4. Instructions répétitives
  • 5. Principaux types de données
  • 6. Fonctions prédéfinies
  • 7. Fonctions originales
  • 8. Utilisation de fenêtres et de graphismes
  • 9. Les fichiers
  • 10. Appronfondir les structures de données
  • 11. Classes, objets, attributs
  • 12. Classes, méthodes, héritage
  • 13. Classes et Interfaces graphiques
  • 14. Et pour quelques widgets de plus
  • 15. Analyse de programmes concrets
  • 16. Gestion d'une base de données
  • 17. Application web
  • 18. Communications à travers un réseau
  • 19. Annexes

 
Critique du livre par la rédaction Guillaume Duriaud le 19 octobre 2005 

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.

 
couverture du livre Au coeur de Python - volume 2

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Au coeur de Python - volume 2

de Wesley Chun (Auteur), Marie-Cécile Baland (Traduction), Anne Bohy (Traduction)
Public visé : Intermédiaire

Résumé de l'éditeur

Python est un langage de programmation agile, robuste, expressif, entièrement orienté objet, extensible et adaptable. Il combine la puissance des langages compilés à la simplicité et la rapidité de développement des langages de scripts. Avec cet ouvrage, écrit par un développeur et un formateur émérite en Python, étudiez en profondeur les caractéristiques clés de ce langage hors pair. Apprenez le style Python professionnel, les meilleures pratiques et les bonnes habitudes de programmation. Ce second volume est un complément indispensable au volume 1 pour aller plus loin avec Python et programmer des applications dans des situations concrètes. Il vous apprend notamment comment construire des applications Web efficaces, développer vos propres interfaces graphiques ou améliorer les performances de vos programmes en écrivant des extensions en C et dans d'autres langages. Cette édition reflète les améliorations majeures apportées aux versions 2x de Python, notamment la version 2.5, et évoque les possibilités des futures versions

Wesley Chun dirige actuellement une société de conseil spécialisée en génie logiciel en Python et en formation professionnelle ( www.cyberwebconsulting.com ). II programme, enseigne et écrit depuis 1980 et possède plus de dix ans d'expérience en Python. Chez Yahoo!, il a contribué à la création de Yahoo! Mail et de Yahoo! People Search

337 pages, 16 juillet 2007 

Édition : Campus Press

ISBN10 : 2744021954

Commandez sur www.amazon.fr :

33,25 € TTC (prix éditeur 35,00 € TTC) livraison gratuite !
  • 1. Expressions régulières
  • 2. Programmation réseau
  • 3. Programmation de clients Internet
  • 4. Programmation multithread
  • 5. Programmation d'interfaces graphiques
  • 6. Programmation Web
  • 7. Bases de données
  • 8. Extensions de Python
  • 9. Sujets divers
  • A. Corrigé de certains exercices
  • B. Tables de référence

 
Critique du livre par la rédaction Guillaume Duriaud le 23 septembre 2007 

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 succint 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.

 
couverture du livre Au coeur de Python - volume 1

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (3)
 
 

Au coeur de Python - volume 1

de Wesley Chun (Auteur), Marie-Cécile Baland (Traduction), Anne Bohy (Traduction)
Public visé : Débutant - Intermédiaire

Résumé de l'éditeur

Python est un langage de programmation agile, robuste, expressif, entièrement orienté objet, extensible et adaptable.

Cet ouvrage introduit les aspects fondamentaux de la programmation en Python : syntaxe gestion des objets et de la mémoire programmation orientée ou fonctionnelle... Il propose de nombreux exemples pratiques de code pour acquérir de bonnes habitudes de programmation ainsi que des exemples interactifs et des exercices. Des tableaux faciles à utiliser viennent détailler les modules les opérateurs les fonctions et les méthodes.

Une attention particulière est donnée aux nouveautés de Python et de sa version 2.5.

Wesley Chun dirige actuellement une société de conseil spécialisée en génie logiciel en Python et en formation professionnelle ( www.cyberwebconsulting.com ). II programme, enseigne et écrit depuis 1980 et possède plus de dix ans d'expérience en Python. Chez Yahoo!, il a contribué à la création de Yahoo! Mail et de Yahoo! People Search.

645 pages, 12 décembre 2008 

Édition : Pearson Education

ISBN10 : 2744023167

Commandez sur www.amazon.fr :

28,41 € TTC (prix éditeur 29,90 € TTC) livraison gratuite !
  • 1. Bienvenue dans Python !
  • 2. Débuter en Python
  • 3. Les bases de Python
  • 4. Le objets Python
  • 5. Nombres
  • 6. Séquences : chaînes, listes et tuples
  • 7. Type associatifs et ensembles
  • 8. Instructions conditionnelles et itératives
  • 9. Fichiers et entrées/sorties
  • 10. Erreurs et exceptions
  • 11. Fonctions et programmation fonctionnelle
  • 12. Modules
  • 13. Programmation orientée objet
  • 14. Environnement d'exécution
  • A. Corrigé de certains exercices
  • B. Tables de référence

 
Critique du livre par la rédaction Nicolas Vallée le 11 juin 2009 

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.

Critique du livre par la rédaction Guillaume Duriaud le 10 octobre 2009 

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.

Critique du livre par Christophe Kibleur le 23 septembre 2007 

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 partielement, 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 avançé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 filigranne 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 coeur 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 coeur 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.

 
couverture du livre Python en Concentré

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Python en Concentré

Manuel de référence

de Alex Martelli
Public visé : Intermédiaire - Avancé

Résumé de l'éditeur

Présentation de l'éditeur
Python est un langage populaire auprès des développeurs à plus d'un titre. Il réunit de nombreuses vertus, appréciées aussi bien des administrateurs système pour ses qualités de langage de script que des développeurs pour la rigueur de son modèle objet, sa portabilité et son extensibilité. Polyvalent, il autorise aussi bien la programmation procédurale qu'orientée objet. Il s'interface aisément avec des composantes C ou Java. Derrière une simplicité apparente, se cache un langage puissant capable de relever les défis les plus ambitieux. En outre, il bénéficie d'une imposante collection de bibliothèques et de modules d'extension. Python en concentré 2e édition apportera rapidement au lecteur l'information qui lui manque. Dans un premier temps, l'auteur reprend les notions fondamentales du langage. Le reste de l'ouvrage, organisé de façon thématique et alphabétique, fait la part belle aux nouveaux modules qui composent la bibliothèque standard sans oublier les nombreuses extensions disponibles comme IronPython de Microsoft. Parmi les termes abordés on trouvera les deux modèles objet ; les types et les fonctions prédéfinis ; les chaînes et les expressions régulières ; les opérations sur les dates et les heures ; les calculs numériques ; l'interfaçage et la programmation de bases de données ; la programmation réseau et Web ; l'array processing ; la programmation d'interfaces graphiques Tkinter ; le contrôle de l'exécution ; la gestions des threads et processus ; les opérations de test, de débogage et d'optimisation ; l'extension et l'intégration d'applications écrites en C ou en Java. Reconnu comme l'un des meilleurs livres sur Python, cette seconde édition de Python en concentré constituera une pièce essentielle de la bibliothèque du pythoniste, mais également une parfaite introduction au langage pour un programmeur confirmé qui souhaiterait se mettre à Python. Le néophyte l'utilisera en complément d'un ouvrage d'initiation.

802 pages, 15 février 2007 

Édition : O'Reilly

ISBN10 : 284177452X

Commandez sur www.amazon.fr :

50 € TTC (prix éditeur 47,50 € TTC) livraison gratuite !
  • Partie I. Démarrer avec Python
  • 1. Introduction à Python
  • 2. Installation
  • 3. L'interpréteur Python
  • Partie II. Fondamentaux du langage Python et des objets prédéfinis
  • 4. Le langage Python
  • 5. Python orienté objet
  • 6. Exceptions
  • 7. Modules
  • 8. Objets prédéfinis fondamentaux
  • 9. Chaînes et expressions régulières
  • Partie III. Bibliothèques Python et modules d'extension
  • 10. Opérations sur les fichiers et sur le texte
  • 11. Persistance et bases de données
  • 12. Opérations sur les dates et les heures
  • 13. Contrôle de l'exécution
  • 14. Threads et processus
  • 15. Traitements numériques
  • 16. Array Processing
  • 17. Interfaces graphiques Tkinter
  • 18. Tests, débogage et optimisations
  • Chapitre IV. Programmation Web et réseau
  • 19. Modules pour les protocoles réseau côté client
  • 20. Modules pour les sockets et les protocoles réseau côté serveur
  • 21. Scripts CGI et autres possibilités
  • 22. Mime et encodage réseau
  • 23. Texte structuré: HTML
  • 24. Texte structuré: XML
  • Partie V. Extension et intégration
  • 25. Extension et intégration de Classic Python
  • 26. Extension et intégration de Jython
  • 27. Distribution des extensions et des programmes

 
Critique du livre par la rédaction Guillaume Duriaud le 15 septembre 2007 

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 du livre par la rédaction Pierre Chauvin le 8 octobre 2007 

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.

 
couverture du livre Programming Python

Note 4.0drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

Programming Python

de Mark Lutz
Public visé : Intermédiaire - Avancé

Résumé de l'éditeur

Completely revised and improved, the second edition of Programming Python is an excellent compendium of material geared toward the more knowledgeable Python developer. It includes dozens of reusable scripts for common scripting tasks, and is one of the best available sources of information for this popular object-oriented scripting language.

In over 1,200 pages of material, this book offers an extremely comprehensive guide to Python development. Though his book is densely packed with information, Mark Lutz is a lively and witty writer whose focus is on getting things done using the natural strengths of the Python language. To that end, after an introduction and history of the language, the book shows how to use Python for performing automated tasks with files and directories (for example, for doing backups both locally and on Web servers). Not only will this book teach you more about Python, but it will also give you a library of code that you can use as is or adapt for your own projects.

The text covers every conceivable facet of Python and the language's support for networking, files and directories, task management, and even persistence (through its support for shelves). Complete Python programs show how to create e-mail clients, do reporting, and create Web applications (for an online errata database). Chapters on doing graphics programming in Python, as well as coverage of both built-in and custom data structures, are especially good. Because Python is often used for automating installations (in some Linux distributions, for instance), readers will appreciate the sample code and tips for using Python to create bulletproof installs.

Later sections show how get Python to work with C, Java (through JPython), and other languages. The book concludes with useful reference sections summarizing key aspects of Python, like its revision history, relationship to C++, and other material. There aren't many titles on Python, and fans of this up-and-coming language are lucky to have such a solid tutorial and guide available in Programming Python. Perfect for those with just a little previous exposure to the language, it's all you need to master Python in-depth and tap its considerable power for virtually any software project.

1552 pages, 3e édition, 1er août 2006 

Édition : O'Reilly

ISBN10 : 0596009259

Commandez sur www.amazon.fr :

48,92 € TTC (prix éditeur 41,58 € TTC) livraison gratuite !
  • The Beginning
  • System Programming
  • GUI Programming
  • Internet Programming
  • Tools and Techniques
  • Integration
  • The End

 
Critique du livre par la rédaction Miles le 18 avril 2007 

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 enclein à 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.

 
couverture du livre Python par l'exemple

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Python par l'exemple

de Alex Martelli, Anna Martelli Ravenscroft, David Ascher, traduction d'Eric Jacoboni
Public visé : Intermédiaire - Avancé

Résumé de l'éditeur

Robuste, élégant, polyvalent, autant de qualités qui n'expliquent pas à elles seules le succès de Python, car la force de Python, c'est aussi une communauté de programmeurs extraordinairement enthousiastes et motivés, qui se font un point d'honneur à s'entraider. Dans cet ouvrage, vous trouverez des solutions pratiques à de nombreux contributeurs, puis revues et commentées par des maîtres ès python avant d'être publiées. Le livre est organisé de façon thématique. Tous les chapitres débutent par une introduction écrite par un expert reconnu. Au menu de cet ouvrage, vous trouverez des thèmes aussi variés que : la manipulation de texte ; le traitement des fichiers ; la gestion des dates et des valeurs monétaires ; la programmation orientée objet ; la persistance et l'accès aux bases de données ; le débogage et les tests ; le traitement du XML ; la programmation web ; la programmation réseau ; le recours aux itérateurs et aux générateurs ; l'utilisation des descripteurs, des décorateurs et des métaclasses. Python par l'exemple représente une véritable anthologie de la programmation en Python. Les plus grands programmeurs de la communauté ont participé à ce livre Facundo Batista, Fred L. Drake Jr, Mark Hammond, Raymond Hettinger, Mark Lutz, Andy McKay, Gustavo Niemeyer, Paul Prescod, Aaron Watters, avec une mention spéciale pour Alex Martelli, Anna Martelli Ravenscroft et David Ascher, qui ont été les chevilles ouvrières de cet ouvrage. Ils vous livrent ici tous leurs secrets.

Vous aussi, devenez un grand de la programmation en Python en vous mettant à l'école des meilleurs programmeurs. Google, la NASA, AstraZeneca utilisent Python. Pourquoi pas vous ?

525 pages, 13 juillet 2006 

Édition : O'Reilly

ISBN10 : 2841773795

Commandez sur www.amazon.fr :

45,60 € TTC (prix éditeur 48,00 € TTC) livraison gratuite !
  • Texte
  • Fichiers
  • Temps et argent
  • Raccourcis Python
  • Programmation orientée objet
  • Persistance et bases de données
  • Débogage et tests
  • Traitement de XML
  • Programmation réseau
  • Programmation web
  • Itérateurs et générateurs
  • Descripteurs, décorateurs et métaclasses

 
Critique du livre par la rédaction Guillaume Duriaud le 26 septembre 2006 

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://aspn.activestate.com/ASPN/Cookbook/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.

 
couverture du livre wxPython In Action

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

wxPython In Action

de Noel Rappin, Robin Dunn
Public visé : wxPython: Débutant - Python: Intermédiaire - Avancé

Résumé de l'éditeur

Présentation de l'éditeur
How to build a state-of-the-art GUI using the wxPython toolkit.
co-authored by the toolkit's developer, Robert Dunn
the only published source for the wxPython toolkit
complete resource, including reference, tutorial and many unique examples of working with the code.
Because they are often large and complex, GUI programming toolkits can be hard to use. xyPython is a combination of the Python programming language and the wxWidgets toolkit, which allows programmers to create programs with a robust, highly functional graphical user interface, simply and easily. wxPython combines the power of an exceptionally complete user interface toolkit with an exceptionally flexible programming language. The result is a toolkit that is unique in the ease with which complex applications can be built and maintained.
wxPython in Action is a complete guide to the wxPython toolkit, containing a tutorial for getting started, a guide to best practices and a reference to wxPythons' extensive widget set. After an easy introduction to wxPython concepts and programming practices, the book takes an in-depth tour of when and how to use the bountiful collection of widgets offered by wxPython. All features are illustrated with useful code examples and reference tables are included for handy lookup of an objects properties, methods and events. The book enables developers to learn wxPython quickly and remains a valuable resource for future work.

552 pages, 1er mars 2006 

Édition : Manning Publications

ISBN10 : 1932394621

www.manning.com : 49.95 $ seulement

Commandez sur www.amazon.fr :

36,28 € TTC (prix éditeur 42,69 $) livraison gratuite !
  • Part 1: Introduction to wxPython
  • 1. Welcome to wxPython
  • 2. Giving your wxPython program a solid foundation
  • 3. Working in an event-driven environment
  • 4. Making wxPython easier to handle with PyCrust
  • 5. Creating your blueprint
  • 6. Working with the basic building blocks
  • Part 2: Essential wxPython
  • 7. Working with the basic controls
  • 8. Putting widgets in frames
  • 9. Giving users choices with dialogs
  • 10. Creating and using wxPython menus
  • 11. Placing widgets with sizers
  • 12. Manipulating basic graphical images
  • Part 3: Advanced wxPython
  • 13. Building list controls and managing items
  • 14. Coordinating the grid control
  • 15. Climbing the tree control
  • 16. Incorporating HTML into your application
  • 17. The wxPython printing framework
  • 18. Using other wxPython functionality

 
Critique du livre par la rédaction Miles le 17 juin 2006 

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.

Critique du livre par la rédaction Guillaume Duriaud le 6 août 2006 

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.

 
couverture du livre Python précis et concis

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Python précis et concis

de Mark Lutz
Public visé : Intermédiaire

Résumé de l'éditeur

Présentation de l'éditeur
Python, lange de programmation orienté objet, désormais célèbre est particulièrement apprécié pour la clarté de sa syntaxe. Il est utilisé dans de nombreux domaines, aussi bien des programmes ambitieux que pour des scripts simples , et s'intègre facilement dans d'autres applications. Python, langage portable, est supporté par tous les grands systèmes d'exploitation : Unix, Linux, Windows, et Mac OS. Ce petit livre résume l'essentiel de Python : ses instructions et types fondamentaux, ses fonctions et méthodes internes, ainsi que les modules de bibliothèque les plus souvent utilisés et d'autres spécificités du langage. Cette nouvelle édition a été complétée et révisée pour la version 2.4 du langage et aborde donc les derniers développements de Python2.4

164 pages, 23 juin 2005 

Édition : O'Reilly

ISBN10 : 2841773604

Commandez sur www.amazon.fr :

8.55 € TTC seulement (au lieu de 9  € TTC : prix éditeur) livraison gratuite ! (voir conditions)
  • Ligne de commande
  • Variables d'environnement
  • Types et opérateurs prédéfinis
  • Particularités des types prédéfinis
  • Instructions et syntaxe
  • Instructions spécifiques
  • Visibilité et espace de nommage
  • Programmation orientée objet
  • Surcharge des opérateurs
  • Fonctions internes prédéfinies
  • Exceptions internes prédéfinies
  • Attributs prédéfinis
  • Modules prédéfinis
  • Le module prédéfinis
  • Le module sys
  • Le module string
  • Le module système os
  • Le module des expressions régulières re
  • Modules pour la persistance des données
  • Le module graphique Tkinter et ses outils
  • Modules et outils Internet
  • Autres modules intégrés
  • API portable pour l'accès aux bases de données SQL
  • Conseils et tournures Python
  • Modules et outils Internet
  • Autres modules intégrés
  • API portable pour l'accès aux bases de données SQL
  • Conseils et tournures Python

 
Critique du livre par la rédaction Guillaume Duriaud le 11 janvier 2006 

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, focntions sont accompagnés d'une explication succinte (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.

 
precedentsommairesuivant

  

Copyright © 2013 2013 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.