5 comments about Rapid Web Applications with TurboGears: Using Python to Create Ajax-Powered Sites (Prentice Hall Open Source Software Development Series).

1. The information in this book is completely out of date only a few months after it came out. Turbogears 2.0 is going to basically replace every component of TG 1.0. So I would not recommend buying this book unless you want to re-learn everything again when the Turbogears 1.0 codebase is abandoned (it largely already has been as developers move to 2.0 or other frameworks).
   
   Turbogears is a good example of what happens when PR outruns project maturity, and fundamental decisions are abandoned late in a development cycle.



2. I use this book daily. The book is a great read and walks the reader through many of the complexities of modern web-app development in a clear and easy style. Though there are plenty of gotchas throughout the book, the errata site has most of them nailed cold. The clarity of thought and insight into the rationale behind the design of TurboGears are well worth the price of entry. In addition to covering the current state of TurboGears, the book discusses many of the future options for the project, giving it life beyond the 1.0 version.



3. I'm working on a Turbogears app. I find it a good framework. The book, however, is frustrating to work with. I rarely have time to read computer books sequentially. I generally jump around trying to find answers to my questions. I'm not finding answers... just partial examples throughout.
   
   For example, I would expect an AJAX example to have all the pieces necessary to implement an AJAX conversation with the file names clearly labeled. I would expect a diagram of how the pieces interact. What I find is little snippets of code without context and no diagrams anywhere in the book.
   
   I think the authors did a reasonable job of explaining Turbogears from their perspective. It was the editors' job to push them to explain things from their audience's perspective. This has the look of a rush job.



4. This book is terrible. The examples are incomplete and filled with typos. You will NOT learn Turbogears from this book, just how to be frustrated.



5. The book is a basic start, some of the examples have errors in them and there is a leap from examples that map to the taught content to a project called whatwhat that has much more involved code without giving proper background.

5 comments about Python Standard Library (Nutshell Handbooks).

1. This book isn't really a reference for the Python standard library - David Beazley's "Python Essential Reference" probably fills that gap better - but it is a very useful guide to what the library can be used for, with a comprehensive and motivated selection of code examples.



2. This is a nice supplemental text for the Standard Library documentation. Sometimes you find yourself puzzled as to how a module is to be used, even after reading the documentation. This book provides a little extra help in that regards by providing concise examples that point you in the right direction.

   I can't give it five stars because it is a little sparse for the price. Please be warned, the book is almost all code. Don't expect a great deal of explanatory text.




3. I was hoping for something along the lines of the book the "Standard C Library" book by P.J. Plauger. Unfortunately, this book is nowhere near as complete. Still, there are interesting and useful bits here and there, and it does serve as a decent supplement to the Python library book included in the distribution itself.



4. I am a relatively new programmer, who has used only Python and PHP to any significant extent, so ...

   I have Python Essential Reference (1st. edition) and this book side-by-side on my shelf at work. I use Python Essential Reference and the online module documentation almost equally, and I almost never pick up this book.




5. I bought this book in 2004 when I was just starting to learn Python. I never once used it. Its not a bad book, just less useful now than in 2001.
   
   The book covers Python 2.0. Anything before 2.2 for any Python book is probably not worth the trouble in 2006 and beyond.
   
   When looking for information about a Python module I look in Alex Martelli's Nutshell book(2.2) and the go to the online Library Reference. The nutshell is good for background and examples and the Library Reference brings things up to 2.4.
   
   If I am not quite sure what I am looking for then the Python Cookbook (2nd edition) is the most help.
   
   Mark Pilgram's Dive into Python is a great, in-depth look at some of the more useful standard library modules.
   
   I hope Alex Marelli updates his Nutsehell book for 2.4.
   
   There are other good books for learning Python but the Nutshell(O'Reilly), Cookbook(O' Reilly), Library Reference(python.org), and Dive into Python(online or an Apress book) do the best job of covering the standard library,

5 comments about Python Web Programming (Landmark).

1. This book will help anyone trying to learn the Python language. I have used this book many times while writing Python code and it always remains close by! The visual reference is extremely helpful and effective during the learning process and the authors provide just enough written explanation without drowning the reader with a bunch of theory. Can't think of a book I enjoyed or would recommend more!!...



2. The start of the book provides a good start to understanding python. As the book progresses there are several chapters which do not relate to Python much at all. I was wanting to find out about how you connect to a database from python, but there were at least two chapters on data structures and database concepts that were general, and not really related to connecting to and using a database. A similar problem exists with the intoduction to TCP/IP. Essentially the book takes us through a very low level explanation from the ground up of how TCP/IP and HTTP work. A in depth knowlege of TCP/IP is not nessasarily important to programming a web application, as most of the actual implementation of TCP/IP can be hidden from the programmer. I also feel the author was struggling to find things to say, hence the bloat. Would have been better to have been a thinner book that kept to the subject at hand.



3. After reading positive reviews here and Amazon.co.uk decided to buy the book.
   
   There is not much to add to positive points noted by previous reviews but they have omitted one important thing about this book. Up until Chapter 17 the content remains concise, sample code is well documented and explained but chapters 17 and 18 are let downs unless you are willing to do some research on the net and dig out original book code (now residing at holdenweb.com)
   
   Chapter 17 that introduces AWeFUL; An Object-Oriented Web Site Framework starts well and what little is written on it, is well written, however, chapter only contains small parts of the framework and at the end of it, you won't have a working site. Several critical modules are omitted and despite of showing final site running on framework, all you'll be seeing are exactly that: the images from author's screen.
   
   Similar problems to Chapter 17 are present on Chapter 18, the sample site is dependant on several modules not included in the book and unless you download book code from author's website (and couple addtional Python modules as well), you won't be able to build a working website.
   
   On the whole, seems to me that the author has either lost his patience, was running out of space or has tried to write about something he hadn't planned properly and didn't finish on time for book.
   
   Also slight disappointment was, especially, exclusion of MySQL from database usage examples. Already 2002 MySQL was widely used as a database backend for websites and excluding it from a book that deals with web development, it is somewhat disappointing.
   
   Above flaws may sound worse than they really are, just something you should be aware of if you decide to buy this book and expect high standards throughout.



4. Although I bought the book for class, and would normally sell it once class is over, this book was extremely helpful and will definitely be a book to keep for my personal library. It was what title said, and helped me understand the course material better. I am not a perfect student, I am not 100% in any class, but because of this book, I still learned more then I would've attending course alone.



5. If you want to use Python to write a Web Server, this might be the book for you.
   If you want to use Python to write a server-side script, look elsewhere.

3 comments about Introduction to Computing and Programming in Python, A Multimedia Approach.

1. Guzdial presents concepts in simple form that is easy for beginners to understand. Actually entertaining to read. Worth every penny!



2. This book achieves both of the things you would want a Python as a first language book to do - it engages the beginner with things they might actually want to do, but doesn't fail to introduce the deeper concepts that are needed to come to appreciate the beauty and elegance of Python.
   
   Focusing on computing applications in the arts, this book uses a clever approach to enable the beginner to do really interesting stuff, very quickly. There are things in there that would be of interest to any photographer, not just a software beginner.
   
   Yes, Photoshop is faster and easier, but it hasn't got this level of control! If you ever wanted to write your own Photoshop plugins, this book might be of interest just as an alternative way to get to design your own effects.
   
   The end of the book gets carried away, trying to pack too much in. It tries to explain OOP and Swing, HTML, Javascript and SQL. I think this is too much to get into one book, and if you are working through the text yourself without any mentors you should probably not give yourself too much grief if you don't get all the way through it.
   
   Admittedly, it is also pretty darned expensive.
   
   Otherwise great stuff! This book fills a gaping hole in the Python literature. If you are an intelligent beginner, it is a great place to get started in getting real control over your computer!



3. Guzdial teaches Python from the angle that you want to use it to easily manipulate various types of multimedia files. The files might contain images, sounds, video or even just plain text. This gives some of you extra motivation to learn the material.
   
   Along the way, you can learn how images are encoded in JPG, and how colours are represented, either in RGB or HSB. There is a fair amount of image analysis and modifications that can be easily done in Python. This does not approach the sophistication of what Photoshop provides. But being able to do a lot yourself, instead of invoking canned Photoshop routines, might appeal to you.
   
   Audio manipulation is also covered, though perhaps not as extensively. There are more specialised audio tools available elsewhere, especially for music synthesis.
   
   The discussion of movies is very weak. Due to the complexity of what is required. Here I suggest you turn to what Apple and others offer.

5 comments about Python Phrasebook (Developer's Library).

1. Has great little snippets of code. is very clear in what is says and how to achieve your goals. While it seems to be intended at people with prior Python experience. I had previously only done python debugging. and that combined with perl, bash and C experience i was able to pick up the concepts and get functional quickly (I got done what i wanted to quickly). It is a handy little guide that I am sure I will use regularly.
   
   Almost everything I wanted to accomplish I got done just by using this book.
   
   two weak points.
   1) could have covered number formatting in output
   2) dealing with dates is not really covered



2. it is a good book for python beginner. in order to take step to next level, more python books need read.



3. I've been learning Python through the documentation and tutorials that I've found online, including "Dive Into Python", which is a great introduction to Python available as a free PDF. I am writing code in Python and I have not been satisfied with the Python books I've seen and I want to take my code further. I want to write code like a Python programmer would. I need to be reminded of syntax at times, such as splitting strings, but I don't want to go back to the beginner book. I need to learn new ways and new things I can do with Python.
   
   This well written, simple little book fills that niche. You can put it in your pocket and read it on the train. It's well written and succinct. It's not for learning Python for the first time, you need more explanation and examples when you are learning new concepts. This book is a good reminder of things you already learned but has not completely stuck yet.
   
   Examples I have already used are the string manipulation sections, threads and socket programming. I will probably use the HTML parsing examples next. In his examples Dayley does offer explanation. For example, he describes the elements of the try statement, including the finally, the else and the except parts. However this is done in only two paragraphs. It's a good memory jogger and reference if you already know the syntax.
   
   In the string manipulation section, searching strings, comparing strings, splitting and joining, replacing, trimming and formatting are all covered. In addition, there is a little gem about executing strings as Python code. All the examples are useful and can be included immediately in your code!
   
   I think I'll go through this guide pretty quickly, since it's small, but it's valuable and it's worth having. Let me repeat, this book is for a beginning Python programmer who is learning the basics with some other material, or has already learned the basics.
   
   You can always find example code online, in various blogs, articles and tutorials, however it's easier to have one book by a single author that's well written and has a consistent voice. I highly recommend this book, and I wish the publisher would put out more small books like this. They are so easy to carry and have around.



4. A book like this is only useful as a reference manual into API areas your unfamiliar with. Unfortunately, after randomly using this book as a reference a few times I reverted to google.
   
   Code examples are not complete, explanations are lacking, and overall I found little value reading sections of this book independently.
   
   The authors should revise the book so each section stands on it's own without any information from other sections (sections will probably have to become slightly longer to do this / merging similar sections). The authors should provide a minimal *complete* script in each section that demonstrates the topic at hand and nothing else.
   
   In it's current form, I do not think this book is worth the purchase price.



5. Half the book is about internet.
   I was disapointed by the absence of math things. 1 or 2 pages could have given an overview of the main math functions. Also no string-numeric conversion functions such as str(), float()... are given. This book is definitely not for scientists or science engineers/technicians.
   Things presented are detailed, but they are quite limited.
   A fully operational code example often meaningless follows every function introduced. It would be better to my opinion to introduce the functions individualy and then show an example showing several functions in action in a script that means something.

4 comments about Professional Python Frameworks: Web 2.0 Programming with Django and Turbogears (Programmer to Programmer).

1. I bought this book to learn how to write Django. It is pretty bad. Lots of the examples are incomplete and don't actually work. It shows some stuff but leaves lots unexplained. It is very incomplete - I would not recommend it.



2. This book teaches authors' insight about these useful technologies using carefully chosen working examples and sound pedagogy. It is the first book on Django and second book on TurboGears. I recommend the book to the Web Application Development class I am teaching this semester.



3. I found this book to be nearly useless... the code is badly written and the depth of the material barely goes beyond the available (free) online documentation and tutorials, which are BTW, very well written.
   
   If you're looking for information on the featured JavaScript library, Mochikit, save your time... you will find much more just by going to the website.
   
   This is obviously a TurboGears book, the Django portion being an obvious afterthought and lacking some of the important chapters that TurboGears has. Save your money and your time by not buying this book.



4. It's kinda hard to understand what this book is supposed to achieve. I mostly bought it because there were no other books about Django available at the time and I wanted something that went beyond the online Django doc. I did not read the TG parts much, because I wasn't really interested, having tried TG before. The little I read didn't look much better than the Django half though.
   
   Short and sweet is that it did not significantly improve my knowledge of Django. All the examples are pretty much surface-level, intro-to-simple-concepts stuff. Or fluffy examples like RSS feeds without exploring the basics in depth first. Not very insightful, but wordy nevertheless. Could I have used this to get started with Django? I could, but the online doc is way more comprehensive and a quicker read. Part of the problem is that Django and Turbogears get only 100 pages each. While 100 more pages cover a more generic discussion of Python-on-the-web coupled with some Django + TG.
   
   Was the bar too high? Did I have a very deep knowledge of web development and Django? No, I did the online tutorial and have spent maybe a month or two coding on Django full time, with little web development background going in. I do know databases and Python very well. This book, which I had no trouble following, just didn't add much to my understanding. Not to say it is entirely without value, hence the 2 stars.
   
   If it's not a good guide to Django, how about allowing someone, perhaps a manager, to decide between Django and TurboGears? Nope, because the authors do not really compare them. Odd, given the format of the book.
   
   I can understand the authors not wanting to pick sides. However I did expect some comparison. What is Django good at? What is TurboGears good at? Possible comparison points: OS support, hosting availability, general maturity & stability, scalability & performance, deployment strategies (Apache, Lightty...), database support, how to extend with custom code + ORMs, Javascript libraries, depth of online docs and online community, etc... No, nothing of the sort. If anything, the "non-trivial" examples are carefully chosen _not_ to do the same things in both frameworks so that you can't compare for yourself.
   
   Surely TG and Django are not equal and both have advantages and disadvantages? This book wasn't even able to answer that question. In the time you spend reading it you could do both the TG and Django tutorials and start answering it for yourself. Past that point, buy a book about only Django or only TG.

5 comments about Game Programming With Python (Game Development Series).

1. When I buy a book with source code I first run the examples and then I start reading, so I followed all the installation steps and every single example worked nicely so. The book is clear, concise, fun tu read and I do recommend it fully. If you are serious about writing your own online game and learning Python, get this one. It 's worth the money.



2. I know Python pretty well and I find that it is often an excellent way to quickly explore new programming concepts. Python is so powerful that you can quickly get a feel for the subject by coding a bit. At work, you may have to use a different language, but at least you will know the subject. That's how I got to understand XML and unit testing for example. A good book always helps the process though.
   
   As a newbie to games, I found this book to be an excellent introduction to game coding. It basically walks you through the material you need to create simple 2D real time games on OpenGL, including how to code simple multiplayer games (using Twisted for the networking). It does an excellent job of demystifying basic game concepts and makes me think that I could write a simple game myself, given sufficient time.
   
   The code samples, which I mostly did not run though, are well-crafted and minimalist - just enough to get the job done and no more. This is very clean and expressive code where every line serves a purpose.
   
   I am more interested by turn-by-turn web-based 2D games, so I am currently not using the book all that much. However, once I have figured out my user interface, I will surely return to it to learn how to manage game objects, persistence, game states, and the like.
   
   One caveat, and not a big one. As another reviewer stated, the book excels at showing how to develop modular code by gradually building libraries of reusable code that you can use for a number of games. The author pulls off the trick of doing that in a Python-sensible manner, without adding the overhead that Java/C++ would require, but that Python doesn't.
   
   However, the resulting code, while extremely well thought out, easy to describe, and modular, is distributed though multiple classes in numerous files . This makes it somewhat hard to just start hacking his code. I quickly got lost while trying to modify the network protocol he used for the sample tic-tac-toe application.
   
   In other words, while his code structure is very appropriate to a serious production system, I feel that it is a bit too complex for me to use as a starting point. Monolithic code has many drawbacks but can provide an easier _initial_ learning curve.



3. I recently picked this book from my shelf as a my new bathroom material and was surprised what I was thinking two years ago.
   
   The book is outstanding not only in demonstrating python's real power but supprisingly also in game programming. You need a bit of (may a lot of) object-oriented background to really appreciate this book. The skeleton of game concept is very precise and clear once the "high-level" language applied (or outlined).
   
   I give it 5 star, the only problem with this book is sometimes the variable name is misleading (ex. category part), but probably that's just me.



4. Game Programming With Python is not for beginners. I will say that up front. There are many advanced topic that seasoned pros and up and coming programmers will enjoy -- procecedural content, a* path-finding, asynchronous game servers. These are not for the faint-of-heart, but they are exceptional topics for game programming. Having done an a*star path finding implementation back in my brief time as a game programmer, I can appreciate his work.
   
   A lot of the examples and example code are written in Python and written to a Python graphics library, so they may not be pertinent to your development environment. However, some of the topics presented are very applicable to game design, especially some of the advanced topics.
   
   Personally, I liked the book. When I browse books at my neighbor book store, I usually flip to the back to find the interesting things. I skip the Chapter 1 "What is XML" stuff, and head to the juicy stuff in the back. Not so with this book. All of it is juicy geeky techy stuff.



5. First, a warning about my review style: I tend to focus heavily on negative things. That's probably because negative things are easier and more fun to write about. So while this review may have a mostly negative tone, do note that I don't hate this book... I just think it has a lot of room for improvement.
   
   A few years ago I happened to be writing a game in Python when I came across this book at the bookstore. I was already familiar with both Python and game development, but I was uncertain of a few details at the time, and I liked what I saw on a cursory flip-through, so I decided to take it home. A few years later, I am again attempting to write a (different) game in Python, and this book came to mind, so here I am writing this review.
   
   Sadly, some of the information in the book was already out of date when it was published. Python 2.3 was released in July 2003 (this book was released sometime in 2004), and yet this book seems to be written for Python 2.1, which was released in 2001. The language changed a lot within that time, though not so much as to make the code completely obsolete. The book does not take advantage of "new-style" classes introduced in Python 2.2. If the author didn't want to complicate the issue by distinguishing between old-style and new-style classes, he should have used only new-style classes, not old-style. All you have to do to make a class new-style is derive it from the "object" class; the author needed to devote only a few words to the subject. There's no discussion about the semantics of division, which was already in flux: if you put "from __future__ import division" at the top of your module, the expression 1/2 returns a float (0.5); otherwise it returns an integer (0). The new semantics should be taught because that is what future versions of Python are going to use by default.
   
   The most blatant example of the author's ignorance is his recommendation that you download PyUnit. There's no need to because PyUnit has been included with Python since version 2.1! (Again, version 2.1 was released several years before the book was.) The only thing you get by downloading it is an old and obsolete version. To be fair, though, PyUnit's website needs to make it clear right up front that it's bundled with Python 2.1 and you only need to download it if you're using an old version of Python.
   
   The worst thing has been noted by several other reviewers: the heavy dependence upon PyUI, a library created by the author that was never even finished. Although it has been put on sourceforge, nobody has been maintaining it. It would probably be best not to even bother with learning how to use it, because you'll have trouble getting it to work and nobody else uses it. Its only value is that it'll help you follow the book's examples. If you need a GUI for your game, there are others you can find at the pygame website, such as pgu or OcempGUI, both of which are currently maintained.
   
   However, this is not all as bad as it sounds. A lot of the advice is still good, and if you keep learning about Python, you'll figure out how to work around this book's deficiencies. Unfortunately, this book is geared towards Python newbies, who shouldn't be expected to know how to do that. The code seems to be reasonably-written, it's just out of date. The sad thing is, if this book had been released a few years prior, and it didn't depend on a library that nobody uses or maintains, it'd probably be perfect. As it is, it was out of date even when published, and is only more so now.
   
   Most of the good things in the book, such as the chapter on procedural content generation, don't seem to have much to do with Python itself, but rather are good concepts that happen to use Python for the examples. I think the book does have things to teach. But if you're a Python newbie, you'd do well to get another book about Python if you want to use the language as it is now, and not as it was six or seven years ago. Or, if you're an experienced programmer, you could do what I did and "pick it up" using the official tutorials and documentation, which are freely browsable and downloadable online.
   
   On the positive side, the book especially deserves kudos for the idea in the first place. Although I had the idea of writing a game in Python before knowing about this book, the idea may not strike others so readily, especially if they haven't heard of Python. Too many books either start you with writing in C or C++, or else writing in some toy language such as some variant of BASIC that nobody uses. Python is as easy to use as the BASIC dialects, but as powerful as C++. It's just not as fast as C++ -- an obstacle that can still be tackled when you're ready for it. It's a language with a great variety of uses and an established user base, so it'll have use for many things beyond game development, while still being reasonably suited for that task. What more could you ask for?
   
   In summary: the book was great idea, but the execution leaves some to be desired.

5 comments about Text Processing in Python.

1. This book is not for everyone, but for "text processing", I know of nothing else that comes close; this book merits careful study. Note that "text processing" would include many web applications -- http is a text driven protocol. Do not be put off by the first chapter! It is the most abstract of any book I have read in decades. As the book says, you can skip it if it is a problem for you. As an illustration of how good this book is, I am now using regular expressions (selectively), and this was only possible with the help if this book! (If you do not even know what regular expressions are, you have not completed Text Processing 1.01.)



2. I'd second most of the positive statements given by other reviewers. To boot - the author's voice is clear and pleasant. He shares his knowledge as it is, without dumbing it down or condescending. The index is very useful when you want to get in, get the information, and get back to work. This book is a great read for anyone learning or using Python seriously.



3. There is a lot of good stuff in this book, but the presentation is lousy.
   
   The first chapter dives into functional programming using obscure and terse high order functions including nested lambda expressions. He never does provide a "mere mortal" explanation for how these functions work. I was able to figure it out, but then I've been programming for 35 years in 20+ languages.
   
   As a learning experience it was valuable debugging exercise for me, but as something for a programmer who was just getting to know Python, I can't think of a greater turn off.
   
   Python as a rule is easy to read and easy to write. This book manages to make it unnecessarily hard.
   
   Start with another Python book (or two, or three) then come back to this one when you have a lot of time and patience to spend. As I said there *is* some worthwhile information in there.



4. TPIP is an instant classic in that all you need to do is add a solid understanding of python and you can instantly appreciate its classic nature. Text processing is more fundamental to programming than programming itself. For instance, most of the programs a programmer will write will be written with text. So gaining proficiency in dealing with text is key to not only programming but probably every facet of one's experience with a computer.
   
   In TPIP, David Mertz provides the reader with a set of tools for manipulating text in python. The book is organized by type of text processing activity. For example filters are presented from a functional perspective, searching text is presented in terms of regular expressions, etc. Relevant modules are presented with each type of processing task in a reference format.
   
   The greatest value in the book is that it approaches a fundamental and important programming topic that most books would treat sparingly or dismiss outright. TPIP might be in league with Friedl's Mastering Regular Expressions in that it takes outwardly uninspiring topics, makes them interesting, and teaches them with pedagogical finesse. Somehow, Mertz inspires the reader to feel intelligent while presenting the topics in an accessible way. Even mxtexttools becomes comprehensible in TPIP.
   
   TPIP, though, is not without it shortcomings, especially in organization. The review of python and functional programming are put in appendices and the reference material is interleaved with the text, giving the reader a somewhat disjointed feeling as he makes his way through the book. Better would have been to build the book up from a solid review of the python language, proceeding to a thorough treatment of functional programming in python, to then present the meat of the book, text processing, as a well-organized whole with sensible segue between the chapters. The reference material should be moved to the appendices for easy access.
   
   Even if these organization problems are never fixed, one would be well served to study this fine volume.



5. This book is interesting, the field it covers is not one with many texts, so it's hard to do comparative analysis.
   
   On it's strengths, this book is probably best suited for programmers that aren't afraid to learn advanced material. It covers in great detail everything you ever wanted to know about python string processing (and honestly probably a bit more). It has a very readable style, and overall is exceptionally informative. Examples are clear, pointed, and useful.
   
   On it's weaknesses, some material (ie parsers) might be extremely dense and hard to understand if you don't have a CS or Linguistics degree. On the other hand, if you do understand it (and the explanation is pretty good), you will end up a much better programmer for it.
   
   Overall, I'd recommend this book for professionals with theory background that need to do advanced python work. I'd also recommend it to people without theory background, but only if they're not afraid of getting their feet wet. People who are afraid of learning should probably avoid this book.
   
   4 stars mostly because I'm not really sure how to evaluate this book.

1 comments about The Python Language Reference Manual.

1. If you code in python... you should own this book.
   
   Most concise and readable language implementation reference I've ever read. Doesn't get too far down into the details of the interpreter, while giving all the details an advanced programmer will need.
   
   Pros: It takes four hours to read and will teach you things you weren't aware existed in the python language (well, unless you develop for cpython or something).
   
   Cons: You might need a degree in CS to be able to read this book, it assumes a lot of knowledge. On the other hand, it's cheap, so if you don't understand it you didn't waste a lot of money.

1 comments about An Introduction to Python.

1. I have read several texts on python, all of them basically teaching me Java with python syntax. This is the first book I've read that taught me python with python syntax.
   
   Pros: You will finally understand how to write python code. The book leaves no part of the language uncovered.
   
   Cons: This is really a language reference, if you don't know how to program well in another language I don't know if it would be spectacularly useful. It does not cover any API's extensively.
   
   I love it, and for the price you can't go wrong.