Customer Reviews

Expert Python Programming: Best practices for designing, coding, and distributing your Python software

5 star:		(3)
4 star:		(10)
3 star:		(2)
2 star:		(6)
1 star:		(1)

 

 

I was very biased in favor of this book to start with -- I got a free review copy, Tarek is a Python committer like me, and I even found myself quoted by name as early as the intro;-). Throughout the book, I kept *wanting* to like it... there ARE plenty of good and useful materials strewn throughout it... but in the end the overall judgment had to be (slightly) negative, because there are just too many infuriating details -- the book's detailed copyediting was clearly something the publishers badly skimped on. I ran out of steam entering errata on the book's site -- there are just too many small errors and not a few not-so-small ones; I didn't even get started on the many, many cases of awkward or outright incorrect English -- clearly the editors of an author who's not a native speaker of English must put particularly care in that (as a non-native speaker and author myself I'm keenly aware of that) and in this case it absolutely wasn't done.

But let's focus on the GOOD stuff: there's a TON of brief but useful summaries of installing and configuring a zillion useful tools (all open source ones which you can freely download from their various sources), from editors to (kinda;-) "linux emulators" for Windows, from automated build and test frameworks to revision control systems both centralized and distributed, and so on. In most cases you'll want to delve deeper into the documentation of specific tools, and of course there are alternative "competing" tools that can are barely mentioned (or not even mentioned), but the vast collection of simple instructions and author's recommendations is quite useful anyway, in many cases even for tasks that _aren't_ related to Python programming.

Almost as useful (and almost as short) is the overview of method for arranging and structuring development, documentation, testing, and optimization -- these parts would be especially useful to students, who typically never get exposed to any of these issues, at all, in college courses on programming and "computer science". Again, you'll want to delve deeper into each subject, but it's a useful thing to have the very basics laid out compactly and logically. Unfortunately, the author has a penchant for _over_simplifying, and particularly for apodictically asserting (with no or insufficient justification) theses and preferences that are far from expert developers' consensus; to get real value out of the book, you need to read it in an extremely critical frame of mind, ready to question each and every assertion with independent research (many you'll find confirmed, many others you won't).

This also holds for the chapter on design patterns, with such egregious claims as "Singletons should not have several levels of inheritance" -- they should have as few as practical and feasible, *exactly like any other class*; the desire to limit the number of distinct instances (which is mostly about STATE) is quite orthogonal to the issues with subclassing (which is mostly about BEHAVIOR). From this original "totally missing the point" follows a classic howler (which I've seen repeated in a review above): "why not use a module?". I have news for you, Tarek: a module supports *ZERO* inheritance -- which is quite a bit stricter than even the unjustified "should not have several level" claim above. Having to completely give up the usefulness of inheritance just because you want to limit instantiation would be a very limiting engineering tradeoff! If there's no need for inheritance then *of course* you want to use a module - DOH! - but if there IS (or if special methods can really help you) then it's not an option.

Some of the Python-specific parts are even weaker -- I was particularly disappointed at the two pages about "how Python deals with memory", which confuse references and objects and thus don't really help the reader at all with this crucial part of "expert Python use". To end on a high note, though, other Python-specific parts here and there are quite useful, and only partly overlap with the contents of other books on the subject -- things such as 'eggs' and testing frameworks such as `nose'. But overall the Python-specific content of this book (particularly the good and useful parts thereof) is surprisingly little for the title, surely less than half.

Overall, I would recommend this book only to a reader who IS prepared for extremely critical reading and double-checking, is not put out by very un-idiomatic English and frequent minor errors (typos in text and code, etc), and who thinks he can get good use out of the best parts of the books, the selective "survey" and summary instructions about many excellent tools and the simplified coverage of development methodologies.

This is the only book I've found that really talks about Python best practices at length. The author definitely has some good ideas about managing and releasing code, as well as taking advantage of Python's more advanced constructs.

However, there are way too many editing mistakes in here. I understand that English is not the author's primary language, but he should have gotten an editor or reviewer to fix his grammar and punctuation mistakes. More importantly, there are a lot of typos and obvious bugs in the Python code examples used throughout the book. I would recommend the author follow in the footsteps of The Pragmatic Programmer and ensure that all the code in his book actually compiles and runs.

[Publisher Packt were nice enough to send me a copy of this, so I'm completely biased, but fortunately I really liked it.]

I've been using Python for a couple of years now, but only on a single project, so while there are parts of it that I know very well, there is doubtlessly a lack of cross-fertilisation in the things I am exposed to. So I was looking forward to this book.

Surprisingly, for such a straightforward-sounding title, it is not at all what I expected.

What I expected was analyses and illustrations of using Python's more powerful features: dynamic designs; creating classes on the fly; functional programming styles; closures and metaclasses.

Sure enough, there is an early couple of chapters devoted to advanced language features. First up, iterators, and generator expressions, and then the .send, .throw and .close methods on a generator, which induce the yield statement to return values or raise exceptions. This is then used to handily illustrate coroutines as a method of co-operative multi-tasking without the calamity involved with getting all multi-threaded. It's exactly the sort of feature I'd pondered writing for myself for a personal project, oblivious that the language provides it out of the box.

Other low-level topics covered include the indispensable itertools module, interesting uses of function decorators, best practices for subclassing built-in types, sensible use of descriptors and properties, understanding method resolution order and using super, the often-overlooked slots, and finally meta-programming and metaclasses.

Interestingly, this list has only one item of overlap with my expectations. Tarek has done a good job of choosing important but sometimes overlooked topics, and while, inevitably, I was very familiar with some of the things he talked about, other sections were complete revelations for me.

However, this is only chapters 2 and 3! The rest of the book expands in scope beyond Python the language, to look at the environments and tools that make up the Python ecosystem. In a way, this sounded less intriguing to me than the computer-science oriented exploration of language features that I had expected. But having finished the book, I now realise that it was exactly what I needed.

The opening chapter goes through installing Python - a topic which I didn't think needed discussion. But Tarek goes on to cover using MinGW and MSYS to set up a credible command-line environment under Windows. I've always used Cygwin for this in the past, and trying out MSYS (coupled with the project Console) is a breath of fresh air.

This cross-platform development environment is then rounded out a little by installing and using things like setuptools, and some thoughtful notes on integrating Python development into editors like Vim and Emacs, or an IDE like Eclipse.

The rest of the book covers some of the major tools in the Python world.

I've never previously been forced to get to grips with Distutils. Applying lessons from the book to a personal project got me completely up to speed with using Distutils to create packages, making source and binary distributions, using eggs, and distributing dependant packages that together make up an application. The only thing really missing from this is maybe generating stand-alone executables using py2exe (for Windows) or py2app (for Macs), although this idea is mentioned in passing.

The following chapters give competent overviews of a wide variety of topics:

8. Version control systems: centralised, illustrated by Subversion, or distributed like Mercurial. Continuous integration using Buildbot. Presumably you will either already know these inside-out or else will lap them up hungrily.

9. Waterfall, spiral and iterative project life cycles. I'm not sure that waterfall is really used by anyone except in case studies of `what not to do', and I'm also not sure how you could be a developer without being aware of this, but maybe that's precisely the point: You can't be a developer if you don't do this. This chapter then covers setting up an instance of Trac and using it to manage a project's deliverables, defects, and milestones.

10. Documenting a project using ReStructuredText and Sphinx, and including hints on good technical writing. This caused me to completely revamp the content of my small personal project's documentation, and as a result it is both much improved, and shorter to boot. Wins all round.

11. Test-Driven Development. This chapter would be a superb overview of the topic for someone who didn't know about TDD. Although I use TDD extensively at work, I've never used nose, fearing that getting to grips with it might be too intrusive or disruptive. In fact, it is seamless to begin using it in a small way and slowly extend into its more advanced features as and when you need them.

12. Optimisation : General principles (ie. don't) and profiling techniques. I had never used the cProfile module described here, having just whipped up homespun profilers on-the-spot whenever I needed them, and it's a valuable addition to my arsenal.

13. Optimisation : Solutions. Big O notation. Correct use of different collection types. Multi-threading, multi-processing, caching. Not much that is tremendously new to me here, but it is obviously a huge topic to cover in a a single chapter, and it covers the bases competently.

14. Design Patterns, and how they apply (or don't) to Python. It has been said that design patterns, as fundamental and necessary as they are to a software engineers mindset, are a symptom a language's lack of expressivity. You shouldn't have to write huge gobs of code to express simple conceptual relationships. Although Tarek never explicitly says this, to some extent it is born out by this chapter. Trivial (and much-maligned) ideas like the Singleton, after a page or two of alternate implementations, boil down to simply `use a module', i.e. zero lines of code. Slightly more complex patterns such as Visitor, are only a few lines. It is still useful to discuss and name patterns, but on the whole reference implementations are so trivial as to be unnecessary, except perhaps as the most concise and precise method of illustration.

The book overall, then, is a grab-bag of different topics. Each chapter could clearly be expanded into one or more whole books. As a result, no part can be covered in very great depth, but Tarek does an admirable job of getting the reader up to speed enough in each area that they can be self-sufficient and direct their own learning from that point.

It's worth noting the the book is based on Python 2.x, buy because of the high-level approach, this scarcely matters. Get a different book if you need to know about the language syntax and features. Get this to find out how to create and distribute Python projects.

As as result of the broad scope of the book it serves as a brilliant annotated laundry list of `things the Python developer ought to know'. While there will doubtlessly be some sections that you are already deeply familiar with, if you have any interest in discovering your own deficiencies as a Python programmer, I can highly recommend it.

After you achieve proficiency with a skill, you start thinking less about how to use the tools and more about what you can do with them. Python is no different; after you are comfortable with the data types, the idioms, OOP, and libraries, you will probably start to think about the soft skills of programming and how you can practice your craft better. When you get to this point, I would highly recommend picking up this book.

It's not a book about how to program in Python; many great titles already cover that topic well. Instead, it's a book about how to program Python better. It assumes you already are comfortable with the ins and outs of Python: data types, inheritance, object-oriented Python techniques, etc. When you are ready to take your skills to the next level, start here. These are the techniques you'll need to know to flourish on a software development team: naming conventions, "Pythonic" programming, writing good documentation, test driven development, the development life cycle, profiling and optimizing your code, working with version control, etc.

When I set out to learn many of these topics, I spent hours scouring blog postings, reading through news groups, following link after dead link. I'm astounded that someone has put all this knowledge into a single volume; I would have paid hundreds of dollars for this information a year ago.

Some of the high points of the book from my experience running a software development group are the documentation, test driven development, and profiling chapters.

If you want to be good, not just proficient, at Python, take a look at this book. It's bound to become a valuable reference in my library.

As one reviewer pointed out, it's probably not a good book for someone who is already an expert at Python, but if you are looking to become one, I'd start here.

Let me get my criticism out of the way to start. I liked this book, but thought the title was misleading. The title of the book is "Expert Python Programming." At the very least, I would expect a book that was 2/3rd about the Python language, and 1/3 about development processes/code management using Python. The book was inverted... 2/3 were about development processes, including setting up editors, how test-driven development works, version control, documentation, optimization and profiling, with 1/3 about the language itself. I wasn't totally offended by this because I looked at the book before getting it, but if I had ordered this off Amazon I would have been greatly disappointed. [Maybe it's just me, I find language characteristics and how they're used to solve problems more interesting than tools to build/version/editors etc., but I doubt I'm the only one.]

The material in the book is good. The language specific content can be found elsewhere, and likely in more depth. Sections like the one on optimization were good, but brief.

The best parts of the book (and the majority of the book) is devoted to code management and the development process using Python. I would assume that is where the author's main interests lay, and he references a great number of tools for builds, version control, etc. that the other reviewers here have already mentioned. These sections are great for a intermediate Python programmer that wants to move towards an advanced knowledge, as well as an advanced Python programmer who is looking for a different perspective or possibly a better tool for the job.

I'd say anyone reading my review is taking the correct approach... do a bit of research on this book to determine if it's for you before you buy. This may be exactly what you were looking for... or it may be far from it.

Background: I have programmed in Python for about 10 years. I'd consider myself knowledgeable about the language, but not an expert.

Good: I'm straining to think of anything at all. I learned a couple of things: I didn't know of zc.buildout and buildbot, and that py.test can test on multiple hosts simultaneously.

Bad: There just isn't a lot of material here that an expert wouldn't already be familiar with. I was hoping for some masterful techniques like David Beazley's "Generator Tricks for System Programmers" (on the web, google it).

This book covers a lot of material that's not Python-specific and that any competent programmer would already know (e.g., big-O notation, unit testing, agile programming, version control, etc.). To me, this is irrelevant to the book's topic.

I expect any recent technical books to be 1/3 to 1/2 fluff--this book is closer to 1/1.

Finally, the copy editing was terrible. For example, "thats" instead of "that's", "parallelly" instead of "in parallel". Plus run-on sentences that leave you scratching your head. It's clear that the author's first language is not English, but the editors should have cleaned up these problems.

Ugly: Visually, the book is ugly. Look at the table of contents for example.

Also, the preface contains several paragraphs asking readers to report pirated copies of the book. This is obnoxious since my time is wasted reading it even though I *paid* for the book. Even worse, the publishers forgot to make the book worth stealing.

There's a healthy market of books describing the basics of programming and programming languages. And there are plenty of books act as reference material once you've learned the basics. But, there's now a growing market for books that purport to be the next step for those who have mastered the basics and are now ready to take their skills to the next level. One of these books is Expert Python Programming. Under the covers, this book promises to help the reader to be more productive with Python, both in setting up an efficient development environment environment, as well as packaging it all together and distributing it. There's also a chapter on test-driven development. The back cover reads like a checklist of good programmer practices that few would argue weren't laudable, even essential programming goals. Unfortunately, the execution in relaying this information is muddled, and the book reads more like a collection of blog posts rather than a contiguous, coherent work.

Expert Python Programming starts by covering installation of Python, iPython, and setuptools. It also covers selecting an editor. Seriously, if you're opening a book called "Expert Python", and the first thing you need to do is figure out how to edit Python code, you might as well just put this book down, because you're not ready for it yet. Granted, there's some nice tips about setting up vim so that it doesn't do bad things with Python code, and I can understand that not everyone that picks up this book may be at a true level of expert (after all, not everyone who reads Seventeen magazine is necessarily seventeen years old yet), but the chapter sets a poor tone for the rest of the book.

The next two chapters for best practices below and above class level were some of the most confusing chapters in the book. I tried very hard to follow along with what was being demonstrated, but try as I might, I felt I needed to refer to other sources to even get close to what was being presented. These two chapters almost made me dismiss the rest of this book, but I persevered. I'm not sure if it was a fault of mine, or if the explanations themselves weren't enough, but suffice to say, they were a low-point of the book for me.

That isn't to say that this book doesn't have it's good points. The book has god advice within it's pages, and the author knows his stuff. Unfortunately, the editing and overall direction of the book makes it not as apparent as it could be. I wanted very much to like this book, and I think that with a different editor at the helm, this could be an extraordinary book. This book would be good for those who have already made it past the intermediate / advanced curve of Python. Unfortunately, as presented, it takes a strong will to get the good bits out. Those who would be best served by the advice of this book (beginners, intermediate programmers) will find themselves wanting another resource.

The book is great. If you're inclined to buy it, do so. If you're at that point in your path with Python where advancement is required, this book is highly recommended. If you're not either of those things, I believe you still may find something of interest and suggest you give it a peek.

Substantively, the book is a grab-bag of ideas and topics. The text is clear, brisk, and lacking in extras and verbosity that is too often found in technical publications. (I particularly liked that the "Conventions" section took only a half page). What Tarek has done is what a mentor would do: he shows you a modern development toolchain and modern development techniques centered around Python. He walks you through the mechanics of these techniques and tools, explaining how all of these wonderful things fit together to help you. It's not just programs as commands, either, there's plenty of space devoted to development practice and project management. On that front, too, he's a sound advocate for sound practices.

I am a long-time python programmer that comes to the language from the sciences. The Python universe has expanded greatly since I purchased my First-Edition-copy of Programming Python. All of the new functional and meta-programing features have changed the way people approach Python and (in my opinion) greatly complicated the language. After nearly a decade of development, it is still a nightmare distributing and supporting Python programs to non-programmers (particularly on Windows) especially if the program makes heavy use of non-standard libraries. I feel that Python, like Java, suffers greatly for not being able to build native installers out-of-the box. At any rate, Python is changing faster than I can digest on my own. I was hoping that Expert Python Programing would be a sequel-of-sorts to Lutz's Programming Python (now in its Third Edition, a great book). Something similar to Bloch's Effective Java (2nd Edition) (Java Series). At least, I hoped it would give me some tools for managing the complexity. I think it fails on both counts.

My chief complaint is that the book tries to cover dozens of topics (literally) in only a few paragraphs each. Often, you get a quick sentence or two introducing a topic, a short code snippet that tries to illustrate the point and then a reference to the project web site or a general Wikapedia entry expanding on the topic (imagine that, RTFM in a book!). Ziade is no Kernighan and Richie where each small code example practically exudes elegance and style, nor is he Josh Boch where a few thoughtful paragraphs of explanation (by a true expert) go a long way towards illuminating arcane but critical details of the language and its use. Instead, I got the feeling I was looking over the shoulder of a young, hotshot programer during a coffee break as he demonstrates his latest hack.

It is impossible to do justice to Python's advanced features in the short chapters here. Much less trying to introduce an entire software stack for code management, testing, and distribution. Instead of enriching my understanding of Python, I often set down the book more confused and frustrated than before. Is it really this convoluted? The book feels like reading a Wiki. There is no depth, no context, it is just a 340-page list of what should be in a book (probably several books) about expert programing in Python. But isn't yet.

I've read the first several chapters, and its been good so far except all the code examples lack indentation. I'm not sure if this is a bug with the kindle version, or if the physical book is like this too, but it makes it difficult to read the code. I'm annoyed enough that I've stopped reading, which is a shame...