David Beazley's "Python Essential Reference, Fourth Edition" covers Python 2.6 and 3.0, and is thus quite (though not completely) up to date. The author has in essence chosen to present the intersection of the two branches, i.e. omit features of Python 2 that have been removed from Python 3. This volume's pace is rapid and the coverage is quite extensive, so this probably shouldn't be the first Python book one reads.

The Good: this book is approximately 700 pages long; even so, it's not that bulky and is therefore quite manageable. It is split into two parts: 200 pages on the language and roughly 400 pages on the library. The first part is very good, while the second part is unrivaled as of this writing (though this may change when Doug Hellmann's "The Python Standard Library by Example" comes out). Thus, the reader essentially gets two books for the price of one: the part on the language can be read linearly, while the library part can be read in chunks as the need arises. The book also includes an extremely useful Index which is approximately 80 pages long (and also contains unexpected entries, e.g. "chicken, multithreaded, 414"). Moving on to the material covered: Beazley includes an appendix on Python 3-specific concepts, but also offers useful advice on Python 3 throughout the main text (e.g. "To keep your brain from exploding, encoded byte strings and unencoded strings should never be mixed together in expressions"). I particularly enjoyed the sections on decorators, generators, and coroutines in the chapter on functional programming. Beazley has also posted on his website two tutorials on these topics that nicely complement the material in the book. Similarly, the chapter on multiprocessing and threading is impressive, and forms a nice set with the author's talk slides on the Global Interpreter Lock -- it's important to note that Beazley used to be a professor of Computer Science. Probably the most significant aspect of this book is the abundance of examples. I'm pretty sure the phrase that is most often repeated in this volume is "Here's an example". The examples are always enlightening, sometimes clever, but never obfuscating. Finally, the writing may not be flawless but overall it is quite good. Of course, any reference text is bound to be somewhat dry, but within the confines of the genre Beazley has truly done wonders: he has a personality and he's not afraid to show it. This jovial aspect of the writing is present when giving advice (e.g "Try not to mix threads and multiprocessing together in the same program unless you're vastly trying to improve your job security", p. 435), or just for its own sake (e.g. "If you change the code to only poll after every six-pack of beer", p. 469)

The Bad: chapter 1 is fun to read but it is deceptively titled ("A Tutorial Introduction"). For example, Beazley uses a decorator and the seek file method, without explaining anything about either of them. Of course, this book isn't supposed to be introductory, so strictly speaking my quibble is with the first chapter's title, not its content. The biggest problem I encountered while reading the book was the page layout in the majority of Part II: a module is introduced and then its methods are described by showing a name in bold, followed by a description on a separate line. This confused me to no end: whenever I saw a name, for a split second I would wonder if I should look up or down to find the description. This could have been avoided if the more standard tabular form had been chosen more often: name on one column, description on the other. Of course, I understand that this would have increased the size of the book considerably, perhaps prohibitively so. Moving on to more detailed complaints: for some modules (e.g. struct, shutil, os.path) Beazley gives a listing of the contents but, unfortunately, no corresponding examples. To be fair, he does use os.path functionality in a number of places throughout the book (though the index is no help tracking them down), just not in the appropriate section. Delving into even more detail: any book of this breadth is bound to contain minor errors. Here's a selection of such slips, all drawn from the same chapter: in some cases the prose is obscure, e.g. "A method is a function that performs some sort of operation on an object when the method is invoked as a function." (p. 33); sometimes a statement is contradicted in a later chapter, e.g. we read on p. 39 that "Sequences represent ordered sets of objects indexed by non-negative integers and include strings, lists, and tuples." only to find out on p. 68 that "Negative indices can be used to fetch characters from the end of a sequence."; similarly, on p. 45 we read that for dictionary methods like keys() "in Python 3 the result is an iterator that iterates over the current contents of the mapping", while on p. 632 we learn that "these methods return so-called view objects".

These days, the aspiring intermediate Python programmer doesn't have too many books to choose from: Martelli/Ravenscroft/Ascher's "Python Cookbook" is out of date, Ziade's "Expert Python Programming" contains too much material that is not Python-specific, and Alchin's "Pro Python" is only ~ 250 pages long. Thus, for the time being Beazley's "Python Essential Reference" is the obvious choice for a second book on Python. All in all, four and a half stars.

Alex Gezerlis

This book is a wonderful, and very thorough, reference to the Python Programming Language. It has a great deal of information contained therein, with good code examples and explanations so that it's easy to find what you need and put it to good use. It also manages to cover both Python 2 and Python 3 in the same text, which is VERY useful if you're migrating, or even if you're just curious about what differences exist between the two.

The only problem I have with this book is that a great deal of the content seems stripped, verbatim, from the Python Documentation ([...]). Code examples are the same, explanations and descriptions are the same... It's like the author copy-pasted from the python documentation, then glued it all together with a little insight and experience. Perhaps the author contributed to the Python Documentation website as well?

Despite this, the book is still an amazingly invaluable resource. Yes, almost all the information is available for free online. And yes, you can download a local copy of the Python Documentation from the website, for both Python 2 and Python 3, for free. However, in this book, you have a nigh complete reference of BOTH, including insights into each, all in an easy-to-use paperback form. (While I love e-books, they suck for programming. I'd prefer not to alt-tab between the reference and the code all the time.)

So if you don't want to spend money, go download the Python Documentation, it's free and contains pretty much everything the book talks about.

But if you don't mind paying, you'll find that this is a wonderful addition to your Python Programmer's bookshelf.

DISCLAIMER: I have, thus far, only read Part I (the first 199 pages). I may update this review, once I've read Parts II and III

I bought this book about 6 months into learning Python. I had gone through many Python resources, including a 2-day intro course, followed by:

codecademy.com/tracks/python

python-course.eu/

and about 20 different videos on pyvideo.org, my favorite being Hettinger's 'Class Development Toolkit' (watch it. it is awesome.)

Eventually, I got stuck. I didn't know what else to learn, or in what order to learn it.

Fortunately, this book includes a wide variety of topics, most of them presented in a sensible order. Beazley's coverage of each topic is quite terse. For me, this was mostly good. I didn't waste time reading through things I already knew, and when I wanted to learn more about a topic, I consulted Google and Stack Overflow. Despite the succinct descriptions, the book spans over 700 pages due to its breadth. I would hate to imagine how large a book it might be otherwise.

That said, I would not recommend this as an introductory text (at least not for a beginning programmer). It isn't intended to be. Beazley describes this as "a concise reference to the Python Programming language" and says that while "an experienced programmer will probably be able to learn Python from the book, it is not intended to be an extended tutorial or treatise on how to program".

Of course, I used it as a bit of a tutorial, but your mileage may vary.

The vast majority of Beazley's descriptions are quite good. Unfortunately, I found the introductions to Abstract Base Classes and Metaclasses to be too short, with both difficult subjects covered in a mere 5 pages. He comes back to these subjects much later in the book (I haven't yet read those sections), but I would have preferred either a longer introduction, or no introduction at all. Reading this section, I had no idea what metaclasses were used for. I don't have trouble with brevity elsewhere, but metaclasses are notoriously confusing.

Despite that minor quibble, I found this book a tremendous resource, worthy of 5 stars. I have recently started on the Python Cookbook, which I am also enjoying thoroughly.

Structure:

Part I: The Python Language (199 pages) will give you a thorough introduction to Python/the standard library. I would call it a beginning and intermediate level course.

Part II (the Python Library) is 390 pages

Part III (Extending and Embedding) is 32 pages.

Part II covers a diverse collection of subjects (see the index), from math to testing to web programming. I expect to pick and choose from these; I see no reason to read them in order.

Note: According to the O'Reilly site, you can get the ebook version for only $5 more if you own the physical version. It is supposedly kindle-compatible. And non-DRM!

I STRONGLY recommend getting the physical version and, if you need the ebook, paying the $5 at the O'Reilly site.

The code is very hard to read in the ebook version (maybe it would work on the Kindle DX? it was terrible on the regular kindle). I ultimately decided I couldn't deal with it, and had to buy a physical copy. So, I bought the same book twice. Oh well.

Who knows; O'Reilly's ebook may be better than Amazon's. It comes in multiple (kindle compatible) formats. It would be hard to be worse.

Probably like many people, I've been using Python for text-processing, using tools like Pandas, or just as an adjunct to writing shell scripts.

There are no shortage of texts , even those written for languages like R, which can be used/translated in an ad-hoc fashion.

However, this is the one book "about" Python that I'm glad exists and that I'm glad to have at my side, as I start to think about more tasks I can (or perhaps should) be performing in Python rather than biting my tongue and wishing such-and-such a tool had an API for C.

Yeah, I was hesitant, because what do I care about Python 2.x in this day and age? However, I find it important to understand a bit of the reasons for the shift to 3.x -- this isn't a theoretical text, but it's possible to read between the lines and see some logic, and I find it helps me understand better, even though I'm unlikely to even see any Python 2.6 code unless by accident.

I actually appreciate that's it's a smaller size than some of its counterparts in the Developer's Library. For those for whom the print may be a bit too small, I sympathize (my eyes aren't getting any younger either), consider it a trade-off between valuable texts like Prata's C (or C++) Primer Plus and the sheer bulk of those texts. I think it's a good balance.

I don't know if it's suitable for a complete beginner to any kind of programming, but I wouldn't discount it as such: there may well be absolute beginners who can and perhaps should dive right in to a real text, without any hocum-pocum toy programs or insulting exercises.

Anyway, it's the best book about a specific language I've bought in the past year, and I'm looking forward to doing more serious work in Python as I discover more.

I agree with many of the other reviewers of this book. The content is ideally paced for experienced programmers, and the author's writing style is very easy to read. I especially like the fact that the author covers the differences between Python 2 and 3.

However, reading this book with Amazon's Kindle App on a high resolution screen is extremely taxing, as all code listings are fixed-size raster images. In portrait orientation on the Google Nexus 10's 2560x1600 screen, each line of a code listing is less than 1/16th of an inch high, and single quotes are indistinguishable from double quotes. Although one can double click on listings to get a zoomed-in view, the Kindle App renders the larger, fuzzy image in an opaque full-screen pop-up window--a disruptive process which makes reading difficult.

Nonetheless, I am keeping this e-book as the content is just what I was looking for. I just hope that the publisher eventually puts out an update which replaces the code listings with properly formatted text. Addison-Wesley did publish "The Python Standard Library by Example" without this issue, so I know that they have the capability to fix this problem.

It's widely recognized as one of if not the seminal book on Python. The writing is of the highest quality. It is both a thorough reference and an expert level overview of the language features. It's divided into 2 main parts. The first 12 chapters cover the language features, the last 14 chapters cover parts of the standard library. For the first part, detailed discussion of the internals as well as the features themselves takes place. The text is concisely written. It's a thorough overview that does not leave much room for improvement.

The second part is more of a traditional reference to the most important parts of the standard library.

I doubt you'll find something better for Python, tbh... you just can't go wrong here. Probably this will be the only Python book I ever need if that tells you what this is.

The only caution I have for those buying this book is it's reference level material and not really for beginners. More suited for intermediate programmers.

I almost passed on this book because of its 2009 publication date, but I am really glad I did not. The book was released at a critical time in Python history when Python 3 was just released. The author makes clear what the main distinctions between the two versions are.

The first 200 pages deal with the basic languages features and this part of the book was highly readable with well explained details. Examples given are practical. When introducing generators and co-routines the code was simple and easy to understand.

From page 200 on the reference section of the book starts. I found these parts to be slightly less readable although coverage was extremely thorough. For many of the standard libraries, the entire list of functions and parameters are listed. The code here focused on operating system calls, networking, socket, concurrency, and lower level web programming details. It is generally geared towards a system's programmer rather than an OOP programming.

My main complaint about the book is the size of text which is maybe 8 point font. The text should have been at least 2 font sizes bigger as I had to read quite close to the book.

Overall this is an excellent reference for Python and great to have by your side when programming.

I have worked as a programmer for over 15 years professionally, many more if you consider I started at age 12. I have programmed in C, C++, Java, Ruby, ASP and substantially in Perl. Several years ago I heard about Python from a respected source and have been watching its growth in popularity ever since. I have long wanted to try Python, but always reverted back to a language I already knew.

Recently I was forced to make a switch and have to program a project in Python in order to use a provided API. I am so happy that I found this resource, it is exactly what I needed as an experienced programmer to make the shift. The information is provided with the assumption you know how to code. It is dense without much filler. So many programming language books devote the majority of the time to the general process of programming and insufficient time to the language. It is not so with this one.

On top of that this book goes the extra mile to help you jump into the evolving world of Python as it makes the shift form Python 2 to 3. The book is very informative about what is changing and helps you know what works in 2 and what changes will be required for 3.

I would highly recommend this Python book to someone looking at Python for the first time with significant experience in another language.

Pas mal, ce livre, mais un livre de référence (que j'avais choisi pour ça) n'est pas l'idéal pour apprendre le langage et encore moins pour se convaincre que le langage est simple ! Le niveau intellectuel minimum requis n'est pas si moyen qu'on voudrait nous le faire croire !

I caratteri sono microscopici, ho misurato un'altezza di 1.6 mm; forse il libro era stato pensato con un formato piu grande e ridotto per risparmiare carta?

bisognerebbe chiederlo all'editore.

Very good book.Author is an artist!

- Contents are concise and clear

- Book pages are of good quality.

The author of Python Essential Reference is David Beazley, who among other occupations created the open-source SWIG tool and the WAD mixed-languages debugger. His background is pervading throughout the book, in which the reader gets a clear sense of what is happening behind the Python programming language and learns how to use it efficiently instead of considering it as a black box.

The first 20 pages give an overview of the language and although it is called a "tutorial introduction", it should be understood that its purpose is for a programmer to see what Python looks like, and not for a novice to get their first programming course.

The next 156 pages offer a thorough review of the language and its environment. This is a very interesting part and should not be skipped even by people who already know Python. I said "review" but an experienced programmer should be able to learn the language by reading those chapters and putting them into practice with extra exercises.

Instead of simply describing the language, the author also hands out tricks of the trade, showing how to acquire good coding habits while using an sensible approach regarding the performance, which is often essential in a dynamic language. The fourth edition is focusing on version 2.6 but offers some historical perspective by pointing out several elements that were recently improved, or which are about to change in upcoming versions.

The first part of the book concludes with useful recommendations on program debugging and profiling.

The second part contains 388 pages and goes through the Python library, presenting the essential modules together with examples, notes and advices. After all, this is a reference, so we shouldn't expect any less.

Last but not least, the third part comprises 30 pages of precious information on Python/C interface for extending the language or embedding it in larger applications.

An appendix introduces version 3 for those who are ready to make the leap.

For the sake of completeness, if I were to make any reproach or wish for improvement, it would probably be on the overall presentation (and would be a very minor one). The style in the code excerpts could be more consistent in the first part of the book, and the second part could do with more emphasis on the ... reference ... character of the text, perhaps by providing a more convenient way to navigate through the different modules and by using more obvious styles for the different parts. I sometimes had the impression of reading a long listing of modules and methods instead of looking through a reference book. While the contents is superior to other references like "Python in a Nutshell", I found it easier to retrieve what I needed with the latter - a bit on the brink of obsolescence today - than I do now with the former.

I would definitely recommend this book to anyone desirous of improving their programming skills in Python, or having to write optimized code because performance is an issue.

Muito frustrante a versão kindle desse livro. Os códigos-fontes exibidos no livro são imagens de baixíssima resolução. Não dá vontade de ler. Espero que corrijam isso.