5 comments about Python Programming for the Absolute Beginner.

1. I learned Python in three months using this book. I don't usually post reviews but felt the need to do so because of another reviewer's claim that this book is only for windows users. The cd that comes with this book is unfortunately for windows users but the chapter lessons and challenges work for any operating system. In fact, I used this book exclusively under linux and OS X.



2. Years ago I wanted to learn programming, but all the books about programming were as interesting as my math school books so I lost the will to learn until I saw this book. I couldn't put it away!
   It's fun, interesting, and you will be up all night and coding like mad in very short time!
   If you want to learn how to program get this book. Don't even look at the others, get this one!
   The best programming book for beginners!



3. This is a great way to get started in python, but you're definitely gonna need a follow up book if you want to get real work done. Still it covers the basics very well. I really enjoyed how it was very game focused. I wouldn't call this a game programming book, but the fact that all the examples were games made it more interesting and fun to work through to the end. I would have been much happier if the book delved into the topic of Pygame more thoroughly instead of teaching the readers a little used wrapper for it. Still it was a great introduction and it provided me with a good foundation to start from.



4. The only prior programming I had before this book was that of using SQL (very simple compared to `regular' languages since it's a query language).
   
   I'm basically going to repeat what everyone else has said, saying that it is very easy to read through and it's also easy to pick through the language to understand EXACTLY what is going on. I have always been afraid to delve into programming because of the immense math etc. and the fact of having no "wading pool" to get my feet wet safely, but this book is not mind boggling at all. For one who doesn't know anything about scripting, etc. this is great!
   
   I would assume it's good for any beginning programmer, regardless of what language they are looking to specialize in. Also for anyone who uses ESRI ArcGIS products, this is definitely a must if you wish to use their scripting methods for geocoding/processing, etc. (unless you choose VB). After only reading through the first four chapters I found that running scripts with tools in ArcGIS is easily understandable now.



5. I am learning Python in order to make computer games so the examples in this book are exactly what I was looking for. I'm about half way through the book and I'm amazed at how quickly and painlessly the learning is going. I'm planning to get the author's C++ book too as soon as I'm able. I only hope he writes more advanced books!

5 comments about Python Programming Patterns.

1. I was disappointed in this book for essentially the same reasons as Stephen Ferg (see his review dated Dec. 19/2001). I find that the book does not do justice to the 'Patterns' buzzword.

   I suggest you read Stephen's review before you buy this book. I will not rewrite the same comments here. The reason I am writing this review is to say that I find unacceptable that the author would review his own book here, not clearly identify himself as the author, give it 5 stars, and be so vain in his review. I believe in modesty and letting the readers decide for themselves (isn't this what Amazon's review system is for?) as opposed to what the author has done here. Also, as of this writing there is only one person who voted Stephen's review to be 'not helpful' -- and I would not be surprised in the least if it was the author himself put in that vote..!




2. There is a need for a decent book on Python OOP and patterns, but this is not it. This book is simply a poor intro text with a some buzzwords slapped on the front cover. I have not found any of it useful. Try a google search instead.



3. Many of the reviewers here seem rightly disappointed that Python Programming Patterns is not a Design Patterns book rewritten with Python source examples. When I bought this I was expecting something similar, and was at first dismayed that PPP wasn't that book. But as I started to read through it, I realized that this was the first book I'd seen which actually focused on *Engineering* solid and comprehensive solutions in Python. If you want to know how to write a 'Hello Python' application, look elsewhere. For all the rest of us needing some insight into how best to apply Python to problems of any complexity, there is no more appropriate book out there.



4. Alot of discussion has focused on the title of the book. So, it's not a classic "design patterns" book but if you take a second to look at the table of contents you'll figure that out pretty fast. The introduction even states the following in a section titled, "What the Book is Not" - "... this book cannot be a hard-core object-oriented design patterns book." I don't think that's a problem with this book.

   What I think this book does well is cover alot of ground on writing python with some pretty good examples that go beyond the usual intro book stuff. There is talk of threads, regular expressions, abstract data types, modules etc... stuff you need to do real work but that usually gets left out. To me this is really a kind of python for programmers type book with some very good examples. If that's what you're looking for then check out the table of contents. I liked it.




5. Even though the book is light on true examination of the 20 object oriented patterns it contains, it is a great python book. I use the book as a reference and I must tell you that I feel that you get your moneys worth with this book, thus it gets 5 stars...

2 comments about Numerical Methods in Engineering with Python.

1. The content is typical of an undergraduate course in numerical methods. The author employs Python for that. It doesn't tell you how to use various modules available on the net. Instead, the author sticks to the standard few and explains numerical methods from the very basics. The book is very good for an introduction coursework. However, if you are a researcher looking for tools for serious numerical computation and thinking of using Python as an efficient and convenient organizer(or "glue") rather than a number cruncher, you might as well consult the book by H.P. Langtangen.
   
   This book is also useful if you want to get a hang on how a textbook numerical method would work on Python. You can then use the language for a quick algorithm prototyping in your own work.



2. Here is a book that lives up to its description:
   Numerical Methods in Engineering with Python is a text for engineering students and a reference for practicing engineers, especially those who wish to explore the power and efficiency of Python. Examples and applications were chosen for their relevance to real world problems, and where numerical solutions are most efficient.
   
   If you have a background in Numerical Methods and you have experience with Python then you are good to go, but don't expect the book to teach you either. It doesn't say it will do that and it does not do that. The python intro is highly simplified and has some carless mistakes. The numerical methods used via python assume that you know your numerical methods and how, where, when and why to use them.
   
   Great book, just be sure you know what you are getting into.

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.

3 comments about Web Standards Programmer's Reference : HTML, CSS, JavaScript, Perl, Python, and PHP.

1. How the Web has grown! In doing so, and aiding its growth, has been the use and development of several languages. Naturally, Schafer starts with the language that birthed the Web - HTML. Actually this needs its dual ("twin") on a server, http. But Schafer discusses http in a later chapter devoted to CGI.
   
   Hopefully, you should be able to appreciate that HTML is simple. In fact, of all that the book discusses, HTML is the simplest language. Several initial chapters walk you through HTML. It must be stressed that mastery of HTML is needed to make sense of the rest of the book.
   
   The later languages either extend the scope of an HTML file, or they generate the file, roughly speaking. Cascading Style Sheets (CSS) lets you easily factor out common definitions that are used across multiple web pages, where you can imagine that each web page corresponds to a file storing it. Schafer explains how to use CSS to simplify management of a set of HTML files. A centralised way to set common fonts and the like. More robust.
   
   But HTML is a declarative language. Good, because laymen can more easily understand and write such languages. It's easier to say what should be done, than how to do it. But for the times when you need more expressive power on the browser, Schafer offers JavaScript. A procedural language that actually has nothing to do with Java. [The coincidence in names was a marketing ploy.]
   
   Schafer does not ignore the server. CGI is given, as the first generation attempt at server side code. Its limitations spawned the use of Perl, PHP and Python for easier parsing of user input and generation of new dynamic pages.
   
   Each of these languages (HTML, CSS, JavaScript, Perl, PHP and Python) is often the subject of its own book. No surprise then that Schafer explaining all 6 gave us a book of this length!



2. This is a good book to refresh yourself on the syntax of each language, but don't try to learn web standards from this book! It spends about 10 pages in the HTML language section talking about how wonderful tables are when used to control the layout of your entire site. Anyone with any experience in HTML knows that this is a very bad idea. The Perl section had a few things wrong in the code as well. Overall, I was not impressed with this book. I probably could have gotten better tutorials for free on the internet.



3. This is a great reference book for beginners... I myself am a seasoned systems analyst and already had books that covered most of the basic topics discussed in this book. There were no real world examples and nothing about the pitfalls of using web standards before they are even supported by popular browsers. Like I said at first, it is a really great reference book; and if you need one to get started, this is it! You will still need a book dealing with the methodology variations in coding.

No comments about Python for Unix and Linux System Administration.

5 comments about Data Crunching: Solve Everyday Problems Using Java, Python, and more..

1. Gregory Wilson likes Python and bash but doesn't particularly care for XSLT (or Perl, and possibly Java as well, either), doesn't express a preference in the great Emacs vs. Vi(m) holy war, and divides programming languages into two camps - agile, like Python and Ruby, and "sturdy", like Java. He's an adjunct CS professor at the University of Toronto, a contributing editor with Dr. Dobb's Journal, and is developing "Software Carpentry", which is either a basic course on software development aimed at scientists and engineers for the Python Software Foundation or a project to develop a newer, easier-to-use set of software development tools.
   
   In the book, "Data Crunching: Solve Everyday Problems Using Java, Python, and More", data crunching is explored through a series of examples. The closest that Wilson comes to giving a definition is when, at the start of the first chapter, he refers to data crunching/munging as the "other 10%" of a programming task that takes up the "other 90% of the time". The first example that he gives is his experience helping a high school science teacher convert PDB (Protein Data Bank) files containing the coordinates of atoms in various molecules into a format that a Fortran sphere-drawing program could process.
   
   From the introduction, he moves on to the manipulation of text and text files using Unix command-line tools and Python, with Java work-alikes following most of the Python scripts. Although the book's subtitle, "Solve Everyday Problems Using Java, Python, and More", gives Java first billing (possibly for marketing reasons?), Wilson's preference for Python over Java is never in doubt. After presenting the Java equivalent of a Python script that counts the number of times every email address appears in a list of email addresses, he writes:
   
   All right. It's two-and-a-half times longer than the equivalent Python program, it isn't as fast on small files, and we have to compile it before we can run it, but other than that, it's almost as easy...
   
   With a table of useful commands, explanation of redirection and piping, and some guidelines on how to make sure that your command-line tools follow convention, the text chapter could actually be viewed as a pretty passable introduction to the philosophy of Unix.
   
   The chapter on Regular Expressions is great. So good, in fact, that I wish I could go back in time and give myself a photocopy of those thirty-odd pages at the point that I was struggling to get a handle on RE's some years back. Also included in this chapter is a brief, but very lucid, discussion of character encoding and a bit on using grep.
   
   Although the Text and RE chapters were my favorite, Wilson's clear and concise writing style makes th eentire book, including the coverage of XML, binary data processing, and relational databases, a joy to read. With segues like "But wait a second. Wait just one pattern-matching second.", lists of email addresses to munge that include entries for Alan Turning, John von Neumann, and Grace Hopper, and the like, he also manages to inject some pleasant, if a bit groan-worthy, humor here and there into what could otherwise be a rather dry book.
   
   He uses the last chapter, titled "Horshoe Nails" to quickly address a number topics, like encoding, the pitfalls of floating point arithmatic, and unit testing, which (not a surprise in a title coming from the Pragmatic Bookshelf) he likes, going so far as to say that the spread of test-driven development has been the "real revolution in programming in the last decade"). Diff is introduced and he brings the venerable make to the table as a tool for automating test running.
   
   He doesn't say it in so many words, though his retooling the old saying that "two years of hard work can save you an hour in the library" as "an hour of hard work can often save you sixty seconds on Google" comes close, but the message is to work smarter rather than harder. Use industrial-strength tools and processes when industrial-strength solutions are called for and agile, simplest-things-that-work solutions whenever possible.



2. Data Crunching by Greg Wilson.
   
   The book opens with a statement of purpose: transmuting data from one form into another. The focus is on problems where the hardest part is extracting the data, not problems where the hard part is processing it. Simple transformations and data grazing, rather than data mining, as the ideal problem for these techniques is small, separable, and useful in a variety of contexts.
   
   Major book sections include: Text, Regular Expressions, XML, Binary Data, Relational Databases, and a twenty page miscellaneous section. As usual for Pragmatic Programmer's books, the text is short, coming out at 187 pages, with source code on the web site. That regular expressions come up pretty much immediately tells us that the text will be unix-heavy. Not a bad thing, really, as a few simple unix tools can often save hours of anguish.
   
   Introduction:
   
   The introduction is clear on the intended audience. Read the nine pages, and you have a darn good idea whether the book is worth reading for your tasks. Among other things, the tools he strongly suggests installing - Python, Java, a command line xslt processor, a relational database, and unix command line tools - make it clear the level of this effort. No GUIs, no complicated database reverse engineering tools. Note also, no Perl. (For me, a bonus, but a deal killer for some.)
   
   Text:
   
   Early in the text chapter, the author spends some time examining a data file, then writing out the result. He makes a point of looking up a spec, then ignoring most of it. The YAGNI (You Will Not Need It, for grammarians) says that detailed interpretation of the spec is not as important as carefully making sure it reads the files you actually have to process. After all, your files may be misformatted, or may only use a small fraction of the specification. His example showed that three iterations through some samples got him just about everything he needed, in a very short time. He looked at the input file spec to see if there were corner cases he would need to solve, then focussed on the actual conversion he wanted to make. This theme recurs often - simple data cruncher programs need to be correct, but they do not have the same needs as a general data parsing tool. Do not try to solve every conceivable problem, try to solve the one you actually have.
   
   Interestingly, the author lumps Python, Ruby, and Java on one side, and Perl/C++ on another as far as 'thought collisions' go. Examples thus far include both Python and Java, with more Python than anything else. The Java examples are 1.2+ - using Java 1.5's autoboxing would have simplified several examples to roughly the Python complexity.
   
   The author is not sloppy, but he does take judicious shortcuts. Trimming a file extension in python, he uses a hardcoded three character extension, rather than the more correct .splitExt(). He then mentions that the more correct function required an extra library include, which would have cluttered the text. (The text does mention the more correct function in a sidebar.) A page later, he points out the perils of repeating yourself, and the kinds of errors it can produce. In other words, a bad file extension is likely to cause a visible failure early, while repeated code can lead to subtle bugs. This kind of tradeoff comes up a lot when coding; I was glad to see him make a point of it.
   
   Regular expressions:
   
   Regular expressions are, to my mind, one of the more convoluted topics that programmers encounter on a regular basis. Getting a deep understanding is worthy of a book in itself, and using Perl or Ruby properly _requires_ that understanding. Java now has regex support, though python's is easier to use. He references the standard book on the topic.
   
   The author tries to cover the 10% of the topic that you will regularly use. This will not turn you into an RE-master ready to tackle any Perl you happen to see, but it will be enough for the tasks he is describing. He spent quite some time describing character encoding, Unicode, ISO Latin-1, and the like, which was a welcome surprise.
   
   I note further that not a single Perl example showed up in the RE chapter. Many Python excerpts, some Java excerpts, a lonely-looking Ruby script, but no Perl. Made me happy, but this might infuriate a Perl aficionado.
   
   XML:
   
   The XML chapter goes into a great deal of detail on SAX. The author compares SAX responders to GUI event responders, which felt a bit strained. Most GUI responders do not hove quite the order dependency that SAX responders do. That said, the introduction was clear, and the limitations were explicit. While he did discuss the need to keep state, the discussion came later than I liked.
   
   The DOM section wisely uses language-specific APIs, like Java's JDOM and Python's minidom. I find tree-based APIs more useful than stream APIs in general, and this was a good, if brief, introduction to my most commonly used XML API.
   
   The XPath section is also brief, but clear. Much like the DOM section, the author mentions language-specific APIs. Since many DOM-like APIs have an XPath module, even programmers not planning on doing much with XML will still find it useful. The author draws a paralell to regular expressions - a rich, dense language that can select small pieces out of a large mass of data.
   
   Since I find XSLT a Martian space language, despite having used it heavily for several projects, I was pleased that the author's impression of it matched my own: "I don't really like XSLT that much". The introduction is clearly written, but unlike the other technologies, an introduction does not provide enough meat to accomplish a real problem.
   
   Binary Data:
   
   My rules of binary data: do not use it if you can use text, and if you must, try to find a library. This chapter mentions that on the second page.
   
   The 19 pages of this section cover binary integer representations, string representations, bit shifting, designing self-contained comprehensible binary data formats, and packing as much data per byte as you can. The author did not mention recognizing and parsing gzipped textual data, but other that that, this chapter had a good collection of useful ideas. I have found text, xml, and databases to be more important in my work, but binary files do come up. This chapter reminded my why I always get a sinking feeling when they do.
   
   Relational databases:
   
   This 30 page section gives a good introduction to the practice of SQL databases, using sqlite as the engine. Simple joins and normalizing tables showed up by the fifth page of the chapter. Between aliases, nesting, and negation, the author claims that you should be able to do perhaps 90% of the queries you will need. I rather agree - with the caveat that you do need to understand left and right, inner and outer joins, which are not covered. (They are footnoted to a reference, so expect to snag a good SQL book.)
   
   After joins, the chapter covers aggregation functions, views, and nulls. I give the author credit for bringing up the "Does NULL mean not present, or does it mean unknown" war. Most books take one side or another as gospel, or do not bring it up at all.
   
   A section on creating tables, inserting/updating data, deleting data and tables, and transactions follows. The examples are typical, and appropriate for simple CRUD apps, like many web apps. The author points out that data crunching is far more likely to involve selection than complicated create/update/delete logic.
   
   Finally, the author covers using SQL from python and from Java/JDBC. He also described the impedance mismatch between object oriented programming and the relational model. Wisely, he suggests well tested packages to handle that. I note that the vast majority of my sql has either been in scripts to set up test data or when I was writing an Object-Relational Mapping tool. The vast majority of my code that accesses databases uses well tested ORM packages like Hibernate. (I might have brought Hibernate up earlier in the chapter. Then again, for this book's target audience, perhaps not.)
   
   Odds and Ends:
   
   The final chapter has 19 pages on a variety of tools. The unit testing section discusses JUnit, Make, diff, and TDD. The encoding section discusses HTML escapes, base 64, and others. The section on floating point arithmetic answers the basic questions seen daily on Java discussion lists. Date parsing is discussed in sufficient detail, though I might have added an extra sidebar on just how bad Java's date handling can be. I have little to say about this section, save that it is worth the read.
   
   Final Thoughts:
   
   All in all, this book was well written, well proofed, and well designed. Like all Pragmatic books, it is available as both a downloadable PDF and a bound book. Errata and updates live on the Pragmatic web site. This is an extremely keen system - dead tree form for reading on a plane, PDF form for early access and up to date information.



3. The book presents the topics in conjunction with showing some practical data mining examples that any person might encounter. This book is recommended to people who are interested in basic parsing of data (text, XML, binary, etc) using python.
   
   I got the impression that the author was trying to cover too much in too little space. The title, for example, mentions Java, Python, and more. This is deceiving since the book uses python for about 99% of its examples. And while the book does present Java, it only does so to show that it would be easier to use python. Almost no other languages are covered, although there are some examples in Ruby and Bash.



4. This book is mainly concerned with scripting as a 'glue' between applications: processing various input and output formats. The book is divided into 5 main categories of data handling: plain text, regular expressions, XML, binary data and SQL. There is a final chapter on various miscellaneous topics. Most of the examples are given in Python. Some of the code is demonstrated in Java, although, disappointingly for a book published in 2005, none of the Java 5.0 features are leveraged. However, if nothing else, it demonstrates why Java is not anyone's first choice for such activities.
   
   If you've read any of the O'Reilly cookbook series, you will know what to expect, although the chapters are more cohesive and less episodic. Beginning programmers will get the most out of this book, although intermediate programmers should find at least some material here that's new to them.
   
   The XML chapter is a pretty good introduction the use and advantages/disadvantages of SAX and DOM, and XSLT is also described, although the discussion is not so clear. Those without experience with databases will welcome the chapter on SQL. The discussion on dealing with plain text files in chapter 1 was highlight for me, a subject not often covered in much depth in cookbooks; if, like me, you still regularly need to convert between various plain text formats, this chapter will help formalise approaches that you may already be carrying out in a less than rigorous fashion.
   
   Additionally, the paragraphs on floating point arithmetic were intriguing but all too brief. The chapter on dealing with binary is fairly good, although rather dry. Peter Seibel's discussion of binary data in the context of writing a Shoutcast server in Practical Common Lisp shows that the subject can be dealt with in a more compelling fashion. That said, for the most part, author Greg Wilson is a genial companion; the writing style is chatty, but doesn't overdo it.
   
   Overall, if you own any cookbook-style books, there is little here that you don't already know. Even for a beginner, it's hard to see how anyone who decides they need this book hasn't already been exposed to some of the material here. In particular, does anyone really need yet another introduction to regular expressions? The treatment here isn't bad, it's just that this material is already covered in many introductory programming books (especially those that cover scripting languages like Perl and Python). As this takes up nearly 20% of the book, and there's less than 200 pages, it's a bit of a waste. Personally, I would have preferred more discussion of the less well-treated subjects, some of which are too sparsely described, but this would have detracted from the book's main aim.
   
   This would be suitable for a beginner Pythonista, who for some reason didn't want the bulk of the likes of Python Cookbook. Otherwise, if you feel that some Pragmatic Programmers books can be rather lightweight and somewhat overpriced, this will not change your mind.



5. Some of the best technical books are short, clear, easy to understand, and practical. Greg's book falls into this description. This a great book for exploring algorithms in the python language. The book assumes the reader has at least a basic understanding of the python programming language or some programming experience. I was delighted that topics were presented in a concise and unambigous way and that the book was short. There should be more short books published!

No comments about Problem Solving With Algorithms And Data Structures Using Python.

5 comments about Python How to Program, 1/e.

1. I am a practicing mechanical engineer who's programming experience is based mainly in Fortran90. I wanted to learn Python as quickly as possible, but in a well structured manner. I tried learing Python from the book 'Learning Python', but became discouraged after a few days when the discussion became disjointed. 'Python How to Program' is an excellent book and reference for Python. It is extremely thorough covering many topics including object-oriented programming (three chapters) and web programming. This book will form the foundation of my Pyhton library. Each Python subject is introduced in a simple manner and then proceeds to a more advanced level. Many examples are presented with thorough discussions in each chapter. Detailed summaries are presented after each chapter. This is an excellent book for self-study. I have recommeded it to many of my engineering colleagues.



2. An excellent intro to Object oriented programming in general and Python in particular. A real hefty volume. Wish I could afford it.



3. I purchased Deitel & Deitel's C++ How to Program book long ago, and found it to be comprehensive and extrordinarily helpful.
   
   When I picked up Python How to Program, I expected the same incredible experience. Instead, I was sorely disappointed by their complete lack of Pythonic thinking. It seems as if they took one of their other How to Program books and ran a code converter across it to migrate it to Python. As a previous reviewer pointed out, some of the examples are horrificly implemented, a clear case of programming in Python with the "C/C++ mentality."
   
   The examples seemed fun, but no amount of fun can compensate for the fact that this book teaches you nothing about how to truely be a Python programmer. Anyone can read the lexical syntax descriptions on the python.org website and code the examples in this book. It gives me the feeling that Harvey Deitel did not learn Python for any reason other than to write an expensive book about it, and has no idea how to actually use the language.



4. Bibles, in the profane sense of the word, are huge books filled with clutter and not meaningful structure, which attempt to cover way more than they should. This is a clear example. It might be worth a quick look to a particular chapter, just to get a quick grasp of a particular area like XML, pygame, tkinter, etc. But definitely, this is not the book a beginner should use to learn the language, because as many said before, it seems to be a blind translation from their also crippled Java book. This reader, who cherished their C/C++ book couldn't be more dissappointed.



5. This book on Python is very complete and at the time it was published was better than any other book on Python. It is still an excellent book and has more information than any other Python book on the market. I have used the book as my major reference work for several years. For non-GUI programming you will find most of your questions answered in this book. The general tips on structure and theory of programming are particularly useful for people who do not have a formal education and degree in computer science.
   
   I hope the authors will come out with a new edition that heavily covers newer GUI options including wxPython.
   
   If you are new to Python this book is your best option although there have been some changes in Python since this book was published. If you are familiar with Python it can still be a valuable resource for you. If you have a formal education in computer science and also know the peculiarities of Python then perhaps several more specialized books on particular facets of the language and its uses would be more appropriate for you.
   
   GUI programming is not covered sufficiently in this book to eliminate your need for another book focused specifically on the GUI of your choice. I anxiously await the publication of the book on the wxPython GUI which has been delayed several times and is now due by March of 2006.

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.