Product Description

Like music and movies, video games are rapidly becoming an integral part of our lives. Over the years, you’ve yearned for every new gaming console, mastered each blockbuster within weeks after its release, and have even won a local gaming competition or two. But lately you’ve been spending a lot of time thinking about a game idea of your own, or are exploring the possibility of making a career of this vibrant and growing industry. But where should you begin?

Beginning Game Development with Python and Pygame is written with the budding game developer in mind, introducing games development through the Python programming language and the popular Pygame games development library. Authored by industry veteran and Python expert Will McGugan, who most recently worked on the MotorStorm game for Play Station 3, you’ll be privy to insights that will not only help you to exploit PyGame to its maximum potential, but also make you a more creative and knowledgeable games developer all round.

• Learn how to create advanced games by taking advantage of the popular open source Python programming language and Pygame games development library.
• Learn about coding gaming preferences, sound, visual effects, and joystick/keyboard interaction.
• Discover the concepts that are crucial to success in todays gaming industry, such as support for multiple platforms, and granting users the ability to extend and customize your games.

What you’ll learn

• Take advantage of Python and the Pygame library to build compelling cross-platform games.
• Learn to best use these technologies to turn your dream game into reality.
• Create professional games by accounting for sound, special effects, and user interaction through the joystick and keyboard.
• Build both two- and three-dimensional games, and learn more about the factors that contribute to choosing one approach over the other.
• Provide users with the means for extending your games through level creation and custom modifications as a means to build a vibrant community around your product.
• Package your games in a manner that allows even novice computer users to install, use, and update your games with ease.

Who is this book for?

This book has been written for any budding games developer. While knowledge of the Python language helps, it isn’t required. To help new programmers along, two early chapters are devoted to an overview of Python.

About the Apress Beginning Series

The Beginning series from Apress is the right choice to get the information you need to land that crucial entry-level job. These books will teach you a standard and important technology from the ground up because they are explicitly designed to take you from “novice to professional.” You’ll start your journey by seeing what you need to know, but without needless theory and filler. You’ll build your skill set by learning how to put together real-world projects step by step. So whether your goal is your next career challenge or a new learning opportunity, the Beginning series from Apress will take you there. It is your trusted guide through unfamiliar territory!

Customer Reviews (16)

Good Introduction
As the title says, it is a beginner's book to the topic, though I am unaware of any other books that deal with Pygame as much as this one, beginner or otherwise. The book deals more with the language and libraries themselves instead of "game development" per se. By that I mean there is no chapter on developing ideas or group structures in a company, etc. As a guide to picking up Pygame, though, this book was great. Each chapter uses it's own examples, but I feel that that helps to better cover the topics being discussed, versus a book that creates a game from the ground up throughout the entire book, where the example code may feel unrelated or contrived. As other reviewers have noted, the book focuses more on the example than on the theory, often showing working code and explaining each piece.

The book starts out with an short introduction to Python. The author assumes a general programming background. The tutorials are lacking if you've never used Python before, but some side-reading should give you enough information about the language to continue with the rest of the book. To those who already know Python, the first two chapters serve as a good refresher. The 2D section was great. Everything was in there you'd need to begin coding your own small games. There's an interesting section on AI. The section on 3D design I found myself skipping over, mainly because that wasn't what I was looking to use for my own project. Glancing through it, though, it seemed like a good place to get your feet wet with PyOpenGL (the 3D rendering engine).

There were only a few problems I noted: Occasionally the sample code provided on the website did not function properly, and needed a bit of fiddling with. The code in the book worked fine, however. Events could have been covered at greater length, as they are extremely important in game design. Also, something that I found great but others might scoff at was the author's use of his own gameobjects library. It allowed you to skip the mathematics and just use the functions and get through, but without really knowing how the functions work. Personally I think that's a great approach, because there's no real-world situation in a large game project where you're going to know how all the code works everywhere in the program.

An introduction to the programmming-side of Pygame game development
I just completed teaching a month-long game-programming workshop with this as the primary text.The workshop included both experienced programmers and complete novices: the class consensus was that the text was readable and informative and served well as a basic introduction to game-programming in Python using Pygame.

Other reviewers have commented on depth/balance-of-coverage issues; we had no quarrel with the Python introduction or the 2D chapters, though the 3D material seemed mostly on 3D graphics and not on 3D interactive game design.The AI chapter, with its ant-and-spider simulation, proved a favorite of the students, and many of them cannibalized the state-engine for their own games.

The book is not a comprehensive tutorial on game-creation or game-programming:

It has no specifics on game-design per se:game creation, brainstorming, team-programming, etc.We used material from Fullerton's _Game Design Workshop_ (5 stars, highly recommended) for this.

It has little on code organization beyond the class-level.Multi-file builds, encapsulation of global variables, data persistence using pickle and database classes, etc.

It has little on specific tasks common to games:sprite-based collision-detection, on-screen menu selection, multi-player game issues, high-score pages with user-data entry, score-keeping, multi-level design, etc.

Others have noted the lack of a complete game in the text; while I don't find step-by-step follow-along examples in texts to be of great educational value, a complete example of a 2D game and of a 3D game could have been helpful.That said, Pygame comes with many examples of its own, and there are plenty of free games available on the web.

Overall, the text is what it purports to be, a basic introduction to the programming-side of basic Pygame game development.

Great introduction to Pygame / Python programming
This book is a good introduction to Pygame, and isn't a half-bad introduction to Python. It quickly gets the reader to a starting point on many topics, without getting bogged down into mind-numbing detail.

Very good introduction
I was pleased with the slow pacing of this book, which is good for an introductory course on Python. However, the author only barely taps into the capabilities of Pygame before switching to OpenGL. By the way, OpenGL has absolutely nothing to do with Pygame, so I was disappointed that the author wasted 3 chapters on 3D--hardly enough time for the subject, and pages taken away from potentially advanced chapters on Pygame. Good read otherwise, especially for a complete beginner.

Good only as a very basic introduction

This is a small book (280 pages of core material (Appendices excluded) with lots of source code listings and images taking up space) that aims to teach basic game programming using the popular Python library Pygame, which is wraps the cross platform SDL C gaming library.

The book is very easy going and quick to read, and serves as a nice introduction to the subject, although I definitely don't agree with the subtitle - From novice to professional, because this book will take you very far from a professional, as it's basic at best.

Frankly, I would expect a bit more from a book. It only covers the material on a basic tutorial level and rarely goes deeper, which is a shame. The decision to teach Python and Pygame in the same book is questionable. It's hard to believe a novice will learn Python from the first two introductory chapters, so perhaps aiming the book at Python programmers would be a better idea.

Other cons:

* I don't like the author's using his own mathematical library for manipulating vectors and matrices as opposed to using something like Numpy.
* the author ignores the Sprite class of Pygame and develops his own GameEntity instead. I don't see much justification for this.
* I felt that events were presented in a superficial way. This is probably one of the most important core topics of game programming, and it deserved more attention

On the positive side, the book really is a nice tutorial. If you are familiar with Python and basic math you can actually code a simple game based on this book very quickly, as it contains all the elements you need (at least for 2D games). There's a lot of code in it, and the code is reasonably well written. This code can be used as a jumpstart for your own game.
... Read more

Product Description
Want to tap the power behind search rankings, product recommendations, social bookmarking, and online matchmaking? This fascinating book demonstrates how you can build Web 2.0 applications to mine the enormous amount of data created by people on the Internet. With the sophisticated algorithms in this book, you can write smart programs to access interesting datasets from other web sites, collect data from users of your own applications, and analyze and understand the data once you've found it. Programming Collective Intelligence takes you into the world of machine learning and statistics, and explains how to draw conclusions about user experience, marketing, personal tastes, and human behavior in general--all from information that you and others collect every day. Each algorithm is described clearly and concisely with code that can immediately be used on your web site, blog, Wiki, or specialized application. This book explains:

• Collaborative filtering techniques that enable online retailers to recommend products or media
  
• Methods of clustering to detect groups of similar items in a large dataset
  
• Search engine features--crawlers, indexers, query engines, and the PageRank algorithm
  
• Optimization algorithms that search millions of possible solutions to a problem and choose the best one
  
• Bayesian filtering, used in spam filters for classifying documents based on word types and other features
  
• Using decision trees not only to make predictions, but to model the way decisions are made
  
• Predicting numerical values rather than classifications to build price models
  
• Support vector machines to match people in online dating sites
• Non-negative matrix factorization to find the independent features in adataset
  
• Evolving intelligence for problem solving--how a computer develops its skill by improving its own code the more it plays a game 

Customer Reviews (59)

Popular Web Algorithms Explained in Detail
He makes very good pointers sometimes I lose him through all the math. Don't buy this if you are not willing to pick up phython or if you don't have an extensive math background.All his examples are written in python. I wish he had a PHP version.

Excellent Resource, Clear and Concise
Excellent resource for beginners and experts alike. I was impressed with the organization and the concise explanations that nonetheless explained what you need to know to understand the methods in practical statistical programming being used today. The fact that all examples are given in working code ensures that everything you need to start programming your own applications is provided for you.

The only minor fault in my mind is that it could have been easier to explain some of the hairier concepts with mathematical formulas (which the author avoids, for legitimate reason) in an appendix. An appendix is provided with seemingly similar purpose, but is underdeveloped. This is a minor issue, as all concepts can be supplemented with a simple web search.

Great sample code in Python
A fun, fast read.Good depth, but still concise.The code is well written, broadly applicable, and easy to modify.This book is the opposite of A New Kind of Science.

Bold New Writing plus best O'reilly book ever
This book is spectacular, I love the way that the Author approaches a "new middle" ground of writing books.That is a book that is somewhere in between pure theory, and pure practice. That observation and follow through is simply genius.Python is an excellent choice for this as it can be easy to read.I had to study Python a little before I could totally digest the code.The book is around 300 pages but it is very dense, if someone else wrote it, it would be 600 pages.
Most O'reilly books are boring, useless documentation that you could find on the internet.This book is full of useful examples, showing you how to use "real" data, even how to get the "real" data. For that reason if you are not fond of O'reilly books, don't worry this one is different.

The downside: this book has over 1000 proposed errors and not 1 accepted errors on the O'reilly web site.Some of the code simply does not work as it's written in the book.You can download the code examples but even those do not work 100%.Check the O'reilly site to get the latest code updates.Also the book was published in 2007 and the internet has changed since then so the API's are a little out of date.By not updating this book they are doing the community and they author a huge disservice.

Intuitive and motivating book
I am not completely finished reading it but I already think it's a great introductory book which is strongly committed with transmitting intuition and comprehension of its material (machine learning) usually hard for regular people. It focuses mainly on implementation and application but some general coverage of the underlying theory is done to motivate inexpert readers. Examples are taken from the Web domain so this text can be very useful for people interested in combining BI and AI, among others. Personally, I approve using Python, which is not (yet) my favorite language, I consider it actually as a plus because it complements very well author's intention of simplicity which is all over behind the book design. This book seems to me like an excellent old school teacher among those ones who really take the right timing and words for carefully explaining you something probably difficult in an easy way so that you really will want to learn more about it. ... Read more

Product Description
Python Web Programming is a practical introduction to building networked systems in the object-oriented framework of the Python language. It shows how to leverage the powerful Python libraries to build systems with less programming effort and easier maintenance. It leaves involved discussion of the Python language by itself to other books and dives right into using Python within web enables applications.

This book is intended for programmers who have experience with other programming languages (such a C or C++) and has some experience with building web-based systems. It is for the serious programmer who does not want a basic introductory to the language.

All code developed in the book will be available on the newriders.com website. This is an incredible asset because the Python language allows for modular programming between systems, thus readers in their projects can use code created in the book. ... Read more

Customer Reviews (16)

Not right on the mark
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.

Python Book Review
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.

Great book somewhat let down by loss of focus at the end.
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.

Too much background information
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.

Trying to Learn Python? Check this book out!
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!!... ... Read more

Product Description

For any student or professional interested in learning the fundamentals of Python

In this one-of-a-kind video package, leading Python developer and trainer Wesley Chun helps you learn Python quickly and comprehensively, so that you can immediately succeed with any Python project.

Just click and watch: One step at a time, you will master Python fundamentals. If you already have Python experience, these videos will help further develop your skills. The lessons start with an introduction to the core features of the Python language, including syntax basics and standard types and operations. The lessons progress into advanced topics, such as Python’s memory model and object-oriented programming.

This LiveLessons video course closely mirrors the topics covered in its sister publication, Core Python Programming, Second Edition (Prentice Hall, 2007). As in the book, viewers will find review questions and coding exercises at the end of each lesson in the video booklet to test the material introduced in the video and printed parts of the lesson.

Customer Reviews (2)

Mostly recordings of slides with audio narration
This is most certainly not a step by step introduction to Python programming, though technically it is a slide show about the fundamentals but only for someone who already knows a similar programming language.It is NOT for someone who has never programmed before.It is merely a lightweight summary of the content in the author's book, Core Python Programming, of which he'll refer you to more than once to learn about topics he really should be covering, despite the fact that this video slide show actually costs more than the book!No need to read any further, just get the book and skip this waste of money.

If you prefer to watch a video of mostly slides with text on a blue background while the presenter narrates (yawn), and see very little actual video of live coding being done to illustrate the lessons or provide hands on step by step Python programming insight, then this is the product for you (yawn).Many lessons don't even have any video of programming in Python at all! The most coding you'll see is the narrator going through the interactive shell in Lesson 2 rushing through a "Demo" of interactive commands.After that, videos of the author actually doing something get progressively rarer.It's baffling why the author agreed to even do a "Live"Lessons video at all, or why the publisher would release it as a "Live"Lesson along with a misleading description.

On the other hand, why pay for something when there's no shortage of free Python videos of slide presentations on the Internet that are as equally theoretical and not particularly engaging or illustrative?But, if you insist on buying a Python video tutorial, then you'd be better off looking for LinuxCBT's Python scripting video which clearly shows what a live lesson is all about though it isn't cheap.

Python is an interesting language, and deserves better treatment than an uninspiring, overpriced slide show presentation sold as a "Live" Lesson.This might actually turn new programmers away from Python.I'd advise new programmers to search MIT University's website for an entire free video course introducing beginners to programming using Python as their first language.

The LiveLessons series are a bit of a hit and miss in quality, but future authors could benefit greatly by watching how Bill Jelen (Mr. Excel) does his LiveLessons videos.If LiveLessons ever covers Erlang or Clojure, I can only hope they'll use slides to only briefly introduce the theoretical topic, then actually show how a programmer implements the topic for illustration, passing along insights only an experienced developer could as he codes multiple practical examples of the theory.

excellent introduction
While there are numerous excellent web resources for python, sometimes video instruction can
make things move along faster. All the key into topic areas are covered here with clarity if not great depth. A good value.
... Read more

Product Description
The Python 2.1 Bible provides the only complete Python language reference on the market and includes all the information and software that developers need to use Python as a rapid application development tool.

The Python 2.1 Bible fills a critical void in the Python reference market. Although it includes a complete Python language reference section, it is still geared towards those of you who already have some programming experience. This book explains each piece of technology in depth and shows through clear examples why each feature is useful. This is the manual you've been waiting for -- the one that covers all major Python components without glossing over how the various pieces fit together. ... Read more

Customer Reviews (10)

Python 2.1 Bible
The book does cover a lot of ground regarding Python and tool kits that are available.

I found it a bit too advanced for someone just getting into the language, however if you already have some familiarity with the language it would help you expand your knowledge beyond the basics obtained with the initial download.

It just covered to much ground to do the job completely and although I know it will become helpful in the future it was the wrong place for me to start.

Very useful
The documentation that comes with Python is woefully inadequate (pitifully lacking in examples, links and clearer writing), which means that any Python user will need to buy some extra documentation such as this wonderful book.
Although this book needs to be updated now since the current version of Python is 2.5, it's still an extremely useful book with instantly useful examples. If they came out with a second edition I would snap it up.
The writing style may not be a paragon of elegance but it is straight to the point. I would also recommend "Python in a Nutshell" as an extra reference.

The best kept secret of Python books
I am a fan of this book!

First and foremost, all the information I needed to write Python programs was there and it was easy to find. This means the book is well organized and the index is great. Don't forget to check out the book's website too.

Secondly, the book covers topics no other book that I know touches. Read the TOC of Parts IV and V by clicking the book cover picture at the top of this page and you will agree.

Thirdly, the authors have a concise style, which you will learn to appreciate after reading chatty Pythonist folks like Lutz. Bruek and Tanner tell you just what you need to know and they use only as many words as needed for this purpose.

Finally, I like the fonts used in this book. They are special, even the one used for Python scripts, and they set the apparence of this book apart from your typical computer language book.

The coverage of the OOP could indeed be expanded, and, most importantly, the book needs a new edition to cover the latest Python version (2.4 as I write this). I would buy a copy of the second edition on the spot.

A good introduction
With a background of C/C++ and Java, I was dropped in the Python deep-end by a client who had a systems monitoring tool written in Python that needed urgent enhancements made. I ordered the Python 2.1 Bible and the client provided Programming Python 2nd edition (pub. O'Reilly). The O'Reilly book looked at first sight more useful, but I choked on it as it assumed prior knowledge of Python. The Python 2.1 Bible, on the other hand, assumed no prior knowledge of Python and within 3 days (whilst waiting for a Linux box to arrive !) I had written a number of powerful disk utilities, socket-based clients and servers, small GUI-based programs etc that ran on my Windows-based PC and which should run on Linux too (still waiting for the box !!). For me it was an excellent introduction to Python. After reading the Python 2.1 Bible I felt able to read Programming Python. Still waiting for the Linux box though so still haven't written the "urgent" enhancements...

The only negatives I would have for Python 2.1 Bible are:
(1) that it assumed C/C++ knowledge (which was fine for me but might not be for other people)
(2) a (very) few areas could have done with a bit more explanation, raising questions that experienced OO people would want answered

Excellent book...
Without a doubt the best and most helpful python book that I've read to date. ... Read more

Product Description

You’ve long been enamored with the Python language, and have mastered its many nuances. Yet something seems to be missing—a productivity boost that you know is possible but you’re not sure how to go about it. This was the sentiment of so many developers before discovering Agile programming paradigm, which embraces concepts such as automation, effective code management, and test–driven development.

Foundations of Agile Python Development is the first book to apply these sought–after principles to Python developers, introducing both the tools and techniques built and supported by the Python community. Authored by Jeff Younker, a well–known member of Python’s agile community who is perhaps best known for his creation of a popular Python testing framework, this book is sure to be a hit among readers who may have reached their limits of knowledge regarding the Python language, yet are seeking to improve their understanding of how sound processes can boost productivity to unparalleled heights.

What you’ll learn

• Understand why the Agile movement is increasing productivity and decreasing programmer stress the world around.
• Use Eclipse and Subversion to add a whole new level of efficiency to your daily programming activities.
• Change your perspective on testing from a necessary evil to a compelling and crucial part of your development process.
• Automate your build process, eliminating much of the tedium surrounding testing and deployment tasks.

Who is this book for?

Python developers seeking to take advantage of efficient developer tools and techniques to boost productivity

Customer Reviews (4)

Awesome Book on Agile Python, But OUTDATED
If you are looking to purchase this book, and you are in the year 2010 or beyond, DO NOT BUY THIS BOOK. Please continue reading my review below, however, to understand why.

This book is outdated because:

1. It has extremely detailed instructions for using eclipse (the IDE) with pydev, mylyn, and pydev-extensions. Eclipse has changed a LOT since this book was written, and the instructions are no longer accurate. The pydev-extensions plugin doesn't actually exist anymore, it was merged with pydev. This can be confusing for new users trying to get things running.

2. The instructions for getting buildbot running are no longer correct. Buildbot has changed a bit as well, and the details for installation is different than it used to be.

3. It spends a while talking about pMock, one of 2 python mock libraries, which hasn't been developed since 2004 and is considered obsolete.

4. It spends a while talking about pyfit, which hasn't been worked on since 2006 and is also not commonly used.

Now, for my thoughts about the book itself:

I decided to give this book a 5 star review because it is an excellent book:

- The author writes extremely well, and has a bit of humor throughout the book.
- The author covers extensions why TDD is good, how it helps, and how it should be used.
- The author describes the different types of testing, and provides clear, intuitive, and thoughtful examples that clearly demonstrate *how to* do the testing.
- The author covers extremely detailed setup / installation / configuration of the tools and development environments discussed.

The reason why I have to not recommend any readers purchase this book though, is that it is sorely in need of an update. I just finished reading this book (August, 2010), and it is very clear that it is outdated. This book would have been extremely useful two years ago, and maybe also the first quarter of 2009, but agile practices and tools have changed so much since then that this book really needs to be rewritten.

My advice to readers who are considering purchasing this book is to do so only if you are aware of what you will be getting, but would like to make use of the author's code examples, writing, and TDD explanations while disregarding the tools used.

I really did enjoy reading this book, however, and I really hope that Apress forces Jeff to release a new copy.

An extremely useful book for Python programmers.
If you're like me, you started programming by writing code. You learned the syntax, looked up things as you went along, and eventually became a proficient programmer. In other words, you took the bottom-up approach.

Now you're hearing all the buzz-words: agile, revision control, test-driven development, unit testing, stubs, mock-ups, code coverage, and more. This stuff requires a top-down approach -- understanding it on a high level before being able to use it to its fullest. Sure, you probably use CVS or Subversion and test your code. But this book gives you the full picture, and ties everything together.

If this wasn't taught in school when you learned to code, or you earned your skills the hard way, and you love Python, then I wholeheartedly recommend this book. Check out the table of contents and see for yourself. I like the fact that it explains the high-level concepts clearly and with enough background that you feel like you "get it" before moving on to the examples.

Likely very good for a niche audience.
I think the author does a fine job of presenting what he set our to do.However, what he did is likely targeted to a rather narrow audience - one that I think could be broadened.I think an overview of IDEs suitable for the environment would have been more appealing than choosing one and relying on the specifics of it to demonstrate Agile Development.Same with the choice of revision control.If you are working in an environment with the author's choice of IDE and revision control, then you will likely be very content with the lack of overhead perhaps required by offering other tools.I don't use the author's choice of IDE or revision control and this does tend to infringe on the broader aspects of Agile Development applicable to many python development environments.You kind of have to parse through some really well-written work and say 'this would be great if it referred directly to my development environment.'I give kudos for the work but wish it were either expanded to hit a larger audience, or was appropriately abstracted to keep the tight flow, minus the specific tools.

Just the intro chapter is worth it
I was not disappointed when I started reading this book.
The first chapter which covers the theory of "Agile Development", is just great.
Now, I am no agile programming expert. The only thing I currently do is write a lot unit tests. But I think I will take some advice for the future (like pair-p.) from this book.
The pace of the book is great (relief after the lutz books), and the authors personal experience in the field is both reassuring, encouraging and interesting.
Coming from a background of C#.NET I am glad that python is getting some help in IDE department and will certainly give some tools a try.
I love the book but YMMV.

Errata (apress does not provide one):
P.99: There is a mention of configure.py in the file list of svn with ? status. This file was never mentioned before.
Where did it come from and what does it represent???

p.109: " 'factory': f " should really be with "f1" at the bottom.

p.112: When issuing "create-slave" command the slave name used is "rsreader-linux"
whereas it was configured to be "slave-lnx01". ... Read more

Product Description
Contents
1 The way of the program 1
1.1 The Python programming language . . . . . .. . . 1
1.2 What is a program? . . . . . . . . 3
1.3 What is debugging? .. . . . . . . 4
1.4 Experimental debugging . . . . . . . 4
1.5 Formal and natural languages . . . . . . . . . . . 5
1.6 The first program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7 Glossary . . . .. . . . . . 6
1.8 The COMP150 lab . . .. . . . 7
1.8.1 Logging-on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.8.2 The OSX desktop . . . . . . . . . . .. . . . 8
1.8.3 Menus . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . 8
1.8.4 The dock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.8.5 The Finder window . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8.6 Your home directory . . . .. . . . . . . . . . . . . . . . . . . . 10
1.8.7 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8.8 IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.8.9 Getting help . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.8.10 Coursework files . . . . . .. . . . . . . 13
1.8.11 Terms requirements . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.9 Blackboard . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . 14
1.10 Laboratory exercises . . . .. . . . . . . 14
2 Variables, expressions and statements 19
2.1 Values and types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Variable names and keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Evaluating expressions . . . . . . . . . .. . . . . . . . . . . . . . 22
iii
2.6 Operators and operands . . . . . . . .. . . . . . . . . . . . . . . . . 23
2.7 The modulus operator . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.8 Order of operations . . . . . . . . . . .. . . . . . . . . . . . . . . . . 24
2.9 Operations on strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
... Read more

Product Description

Customer Reviews (4)

Another good title from O Reilly
It didn't take long for me to read over this book and come to grips with Google App Engine.

It quickly helped me know what the App Engine would be great for and the limitations of the platform.

Id recommend it for anyone looking at using the platform as it saves you hours of looking though online documentation that I found a bit thin and can help you come to grips with the use of the platform for Java and Python.

Having Django in the book is also a great plus.

Excellent Reference for the Experienced Programmer
I've worked with the App Engine for about six months and have gained most of my knowledge from the online documentation.I wish I had had this book when I started. This is the best explanation I've seen of entities and how they relate to transactions. The code examples in Python and Java are extremely helpful and give great insight into how the two languages approach the App Engine abstractions. The sections on data modeling and Django integration are particularly good.Not only did this book fill in gaps in my knowledge, but it is sufficiently detailed that I'm sure I will keep it on my desk as a reference.I've tried the other App Engine books and this is by far the best.If you have any interest in the App Engine, start here.

A Good Guide For Experienced Web Developers
This is a great, and fairly in-depth, guide to the Google App Engine API's. It presents both Python and Java API's on equal footing. Navigation through the book was very clear and straightforward whether you want to take the Java or the Python path. The development environments are presented as well. This book will be most useful if you are already familiar with web application development and just need a tutorial with simple examples for how to do this type of programming on the Google App Engine framework.

App Engine for the real world
I think the book does a great job at explaining Google App Engine. There was no "technical fluff" added to the book which I always appreciate. By "technical fluff" I mean unneeded text which should be looked up else where like in documentation. Also, I found the book very easy to follow and found I could manage to jump around from one chapter to another without reading the book linearly. For example, I was able to read the 1st chapter and a half and then jump to the Django chapter and get a sample Django 1.1 app with the admin interface live on App Engine without much trouble. ... Read more

Product Description

Too often, healthcare workers are led to believe that medical informatics is a complex field that can only be mastered by teams of professional programmers. This is simply not the case. With just a few dozen simple algorithms, easily implemented with open source programming languages, you can fully utilize the medical information contained in clinical and research datasets. The common computational tasks of medical informatics are accessible to anyone willing to learn the basics.

Methods in Medical Informatics: Fundamentals of Healthcare Programming in Perl, Python, and Ruby demonstrates that biomedical professionals with fundamental programming knowledge can master any kind of data collection. Providing you with access to data, nomenclatures, and programming scripts and languages that are all free and publicly available, this book —

• Describes the structure of data sources used, with instructions for downloading
• Includes a clearly written explanation of each algorithm
• Offers equivalent scripts in Perl, Python, and Ruby, for each algorithm
• Shows how to write short, quickly learned scripts, using a minimal selection of commands
• Teaches basic informatics methods for retrieving, organizing, merging, and analyzing data sources
• Provides case studies that detail the kinds of questions that biomedical scientists can ask and answer with public data and an open source programming language

Requiring no more than a working knowledge of Perl, Python, or Ruby, Methods in Medical Informatics will have you writing powerful programs in just a few minutes. Within its chapters, you will find descriptions of the basic methods and implementations needed to complete many of the projects you will encounter in your biomedical career.

Product Description
This book is aimed at engineers, scientists and hobbyists who want to interface PCs with hardware projects using graphic user interfaces. Desktop and web based applications are covered. The programming language used is Python, an object-oriented scripting language; a higher level language than, say, C. The book guides you through starting with Linux by way of a free downloadable, live bootable distribution that can be ported around different computers without requiring hard drive installation. Practical demonstration circuits and downloadable, full software examples are presented that can be the basis for further projects. As well as discrete digital inputs and outputs, the examples cover 12 bit analog to digital inputs. The book also shows you how you can customise your own live Linux bootable CD to include your own projects. No complicated, elaborate, software development environment is used or even required. ... Read more

Product Description

For CS1 courses in Python Programming including majors and non-majors alike.

A problem-solving approach to programming with Python.

The Practice of Computing Using Python introduces CS1 students (majors and non-majors) to computational thinking using Python.  With data-manipulation as a theme, students quickly see the value in what they’re learning and leave the course with a set of immediately useful computational skills that can be applied to problems they encounter in future pursuits.  The book takes an “object-use-first” approach–writing classes are covered only after students have mastered using objects.   

Customer Reviews (2)

Text Book
This is just a well written text book that covers the Python language.Chapters are broken up into different topics that are clear and concise.It really helped me ace the course.

Not as advertised and woefully lacking
Bottom line: if you want to learn Python find a WROX Press or even the dreaded O'Reilly series. This book was written to just rip off college kids. You'll learn little and be left seriously hanging.

This book was required reading for an introduction to programing using Python. Unfortunately it leaves a lot of things out, glosses over the introductory bits, and will leave you searching for more. This book should have an introductory chapter that begins with the title "If you've never used a computer before, read this. If not skip" and have SOMEONE ELSE write it; The heading "You are a moron, but that's ok" works too.

I've used computers very well for 20 years (and I'm not yet 30) but this was my first step into programing. Making that jump from average joe techie to programer needs a bit more explanation, a better job at breaking things down even further. Programing takes an analytical, almost mathematically tuned mind. Making that jump from reading comprehension (memorization and story telling) to reading, memorizing, then applying logically, is not something you can learn overnight. ... Read more

Product Description
"Fletcher and Gardner have created a comprehensive resource that will be of interest not only to those working in the field of finance, but also to those using numerical methods in other fields such as engineering, physics, and actuarial mathematics. By showing how to combine the high-level elegance, accessibility, and flexibility of Python, with the low-level computational efficiency of C++, in the context of interesting financial modeling problems, they have provided an implementation template which will be useful to others seeking to jointly optimize the use of computational and human resources. They document all the necessary technical details required in order to make external numerical libraries available from within Python, and they contribute a useful library of their own, which will significantly reduce the start-up costs involved in building financial models. This book is a must read for all those with a need to apply numerical methods in the valuation of financial claims."
–David Louton, Professor of Finance, Bryant University

This book is directed at both industry practitioners and students interested in designing a pricing and risk management framework for financial derivatives using the Python programming language.

It is a practical book complete with working, tested code that guides the reader through the process of building a flexible, extensible pricing framework in Python. The pricing frameworks' loosely coupled fundamental components have been designed to facilitate the quick development of new models. Concrete applications to real-world pricing problems are also provided.

Topics are introduced gradually, each building on the last. They include basic mathematical algorithms, common algorithms from numerical analysis, trade, market and event data model representations, lattice and simulation based pricing, and model development. The mathematics presented is kept simple and to the point.

The book also provides a host of information on practical technical topics such as C++/Python hybrid development (embedding and extending) and techniques for integrating Python based programs with Microsoft Excel.

The book is accompanied by a CD ROM containing a code library; and a companion website www.wiley.com/go/fletcher_python which will feature code-based updates relating to Python 3.0. ... Read more

Customer Reviews (3)

Poor instructions for using included code
The premise of the book is the use of python in financial modelling. To aid in this the authors provide their "ppf" python extension. However, they do not provide clear explanations of how to install the aforementioned extension (a non-trivial matter). No support is provided on the website indicated in the book. And so, without a working "ppf" module extension utility of the book is severely diminished. Since, I could not rate the book any lower I gave it one star. This has been a large disappointed considering the topic covered and cost of the book. I can not recommend purchasing this title, until a more detailed (included Linux) and updated set of instructions is provided.

This book is so bad, maybe the worst I ever read
I am a quant, dealing with financial modeling on daily basis, and this book is the worst that I have ever used.
I had great expectations because I love python but I was so disappointed.
It is really complicated to use the CD and the explanations are so poor.
The book is mostly full with code without real explanations.
Don't buy this book and don't waste your money. It is very bad.

I dont like to write bad reviews, actually it is my first time but this book is very bad.

useful attempt but confused authors...
Python is useful, no doubt. But have you been involved in the design, implementation and maintenance of a flexible large scale pricing and risk management system? Probably not, because otherwise you would certainly have thought much much harder about the section on misconceptions about python. I don't see that you actually dispel the fact a) python is slow and b) it leads to messy code. Both these features are true. It is too slow for most applications and that is a very serious problem. And yes it does lead to messy code unless you are very organized with very strict rules. Now there are a couple of things that I like about the book. I find the hybrid engineering approach of the authors very good, but I don't think that they go quite far enough in their proposals. They just haven't thought hard enough about the problem. The applications are not useful in a real world application. Basing your argument about python on a cheap implementation of the Hull-White model is just a joke.

Nevertheless this book deserves one star, because I think that python is truly useful for prototyping and can be taken a long way in a real hybrid system. The details will just have to be worked out by somebody else.

Good job, congratulations! ... Read more

Product Description

You’ve learned the basics of Python, but how do you take your skills to the next stage? Even if you know enough to be productive, there are a number of features that can take you to the next level in Python. Pro Python explores concepts and features normally left to experimentation, allowing you to be even more productive and creative.

In addition to pure code concerns, Pro Python will develop your programming techniques and approaches, which will help make you a better Python programmer. Not only will this book help your code, it will also help you understand and interact with the many established Python communities, or even start your own.

• Take your Python knowledge and coding skills to the next level.
• Write clean, innovative code that will be respected among your peers.
• Make your code do more with introspection and metaprogramming.
• Design complete frameworks and libraries (two are included in the book!).

What you’ll learn

• Write strong Python code that will be respected in the Python community.
• Understand the reasons behind big design decisions in Python.
• Write programs that can reconfigure themselves in Python.
• Disguise your code as different types of objects in Python.
• Inspect just about any object in Python.
• Prepare your code for international audiences.
• Ensure code quality with rigorous testing.

Who this book is for

This book is for intermediate to advanced Python programmers who are looking to understand how and why Python works the way it does and how they can take their code to the next level.

Customer Reviews (1)

Great Book
Pro Python, by Marty Allchin, is another book that tries to bring beginner and intermediate Python programmers up to the next level.This book is targeted towards people with a bit of familiarity with OOP in Python and basic control structures, but beyond that no more knowledge is really necessary.Allchin goes on to introduce a wide range of topics to the reader such as decorators, list comprehensions, generators, and annotations.This is only a brief look at what is covered in the first chunk of the book.Allchin also focuses some chapters on software distribution, testing, and documentation, and ends the book with a chapter focused on designing your own framework for parsing CSV files.He also focuses chapters on working with Strings and object management, as well as a basic chapter on functions and classes that will introduce more advanced concepts in these two areas.

One of my favorite aspects of this book is the first chapter "Principles and Philosophy" which focuses on the Pythonic way of writing code and managing a project.He covers about 20-25 concepts that will make you a better Python programmer.In addition, throughout the book Allchin always makes sure to mention when he is teaching something that has a syntactic difference between Python2 and Python3.

I would definitely recommend this book to anyone with previous Python experience that want's to step up to the next level.I also believe that this would be a great book for a person with programming experience in another language who wants to rapidly pick up Python.You might need to read a few resources online while working through the book, but overall, Allchin does such a great job of explaining the concepts he covers that it makes this book a great resource for any developer. ... Read more

Product Description

This short cut is taken from Programming in Python 3: A Complete Introduction to the Python Language (Addison-Wesley, 2009) and provides self-containedcoverage of Python’s advanced features. Most of the techniques covered arenot needed every day, but in the right circumstances they can make a crucialdifference, allowing us to write clean and straightforward code rather thanhaving to resort to hacks and workarounds to achieve what we need. The shortcut explains a range of procedural, object-oriented, and functional-style techniques,and the information provided will be a considerable addition to mostPython programmers’ toolboxes.

Product Description
Mark Pilgrim's Dive Into Python 3 is a hands-on guide to Python 3 (the latest version of the Python language) and its differences from Python 2. As in the original book, Dive Into Python, each chapter starts with a real, complete code sample, proceeds to pick it apart and explain the pieces, and then puts it all back together in a summary at the end.Dive Into Python 3 is a Python book for experienced programmers. Whether you're an experienced programmer looking to get into Python 3 or grizzled Python veteran who remembers the days when you had to import the string module, Dive Into Python 3 is your 'desert island' Python 3 book. If you've never programmed before, Python 3 is an excellent language to learn modern programming techniques. But this book should not be your starting point. Get "How to Think Like a Computer Scientist: Learning with Python" by Allen Downey, Jeffrey Elkner, Chris Meyers and learn the basics. Then dive into this book. Dive Into PYTHON 3 was written by Mark Pilgram, and this edition is distributed under the terms of the Creative Commons Attribution Share-Alike License 3.0. * Money raised from the sale of this book supports the development of free software and documentation.About the Author: By day, Mark Pilgrim is a developer advocate for open source and open standards. By night, he is a husband and father who lives in North Carolina with his wife, his two sons, and his big slobbery dog. He spends his copious free time sunbathing, skydiving, and making up autobiographical information. ... Read more

Customer Reviews (7)

Don't Buy The SoHo Press Edition of this Book
I read the original Dive Into Python (printed by APress) and enjoyed it enough that after starting to read the online edition of Dive Into Python 3 I decided to grab a print copy.I really really should've been paying attention and read the other reviews.The SoHo edition is a poorly printed copy of the content available online, and not even adjusted to fit to the book's format.The text is dithered (and therefore hard to read), and all hyphens and underscores are missing from the text and code samples.

I would strongly recommend looking for the APress printing of this book.I learned to write python from Dive Into Python and Pilgrim's writing style is interesting and engaging enough that I'm planning on rereading through most of Dive Into Python 3 (and have enjoyed the little I have read so far), but please don't reward the author's generosity in licensing this book under Creative Commons by buying a copy that does such poor justice to it.

*very* poor print quality
The print quality of this book is awful.My copy looks like it was printed on a cheap inkjet printer. The print is tiny.Really tiny.And the top and bottom margins are 1-3/8" each!Seriously, is this a joke?

This book probably has some great content, but the print quality is so bad it's worthless.

20 dollar doorstop
After reading a few reviews on what was the best book to learn python, I decided to try out Dive Into Python 3. I however came to the realization, after my purchase, that buying(as this book can also be downloaded free) was a mistake.

Arriving at my door step early in the morning I hurriedly opened the package to "Dive" into it. Firstly, I noticed that the review that stated the book was an exact replica of the PDF version was not joke. The book is littered with many underlined phrases that, on a computer, would surely skip you to a informative webpage or future chapter. No problem, I skip the introduction and go for the meaty bits.

The book teaches python like a biology teacher would teach about a frog's organs. It gave me code that is dissected and then explained. So, as the title suggest, I dived strait into Python by typing the "code" into my computer and observing how it works.

However, while compiling the first example program, I ran into some issues. A real stynax and string definition nightmare. Something wasn't right, I had installed all the right programs, versions matched up and my code was identical to the book, but there where still issues. So I go online and check the HTML version. Turns out the book is printed without any underscores......

Pros:Heavy
Square-ish
Will stop a door or make a good paperweight

Cons:NO UNDERSCORES?!
Source code is useless
Continually have to check online version

My recommendation would be to download the PDF version and give Mark Pilgrim a donation.

good content, horrible latout
I like the book mainly purchased as a handy copy of all that is good and available on the authors website. However the layout is tiring and unconventional enough to be distracting.

good content, but poorly produced physical book
I came to this book after slogging through 200pgs of the tome that is Learning Python and getting nowhere.Dive into Python 3 is a more reasonable size, and from reading a few of the chapters online at [...], I felt that Mark Pilgrim had done a good job of writing a Python introduction.I would probably rate the content as 4 or 5 stars.

I was happy enough that I wanted to buy the physical printed edition of the book, to have as a reference and to support the author.I was expecting that the content had been professionally reformatted for book form, with suitable typeface selection and reflowed text.However, I was sorely disappointed when I received my printed copy.It would appear that SoHo Books has done nothing but take the PDF from Mark Pilgrim's site and printed it.I might not mind, except that this was done very poorly.I immediately noticed that the typeface was small, sans-serif, and worst, dithered!The letters are drawn with small,fine dots as if this were printed on an old dot-matrix printer.The result is unlike any other printed book I have, and I consider this unacceptable.The fonts in the PDF appear to be vector drawn when I scale it, and thus SoHo has no excuse for not doing a cleaner job of scaling the pages down.And that's all they did: take pages formatted for 8.5" x 11" and scale them down to about 5.5" x 7" or so.Further, they wastefully left 1.75" of dead white space on top and 1.5" on the bottom.

This cheap printing is a shameful waste of a tree, when it could have been done really well.I would have a much higher quality version if I had printed it on my own printer.I thank the author for licensing his work with the Creative Commons license, but I'm sad to report that I'll be returning this print version.I'll hold out hope that these problems could be corrected for future printings. ... Read more

Customer Reviews (1)

great value fast shipping
I ordered this book from another seller and it came late and was the wrong book. I ordered it on Amazon and it was 9 $ less and came in less than a week. The book is written well and is easy to use. ... Read more

Product Description
The use of high-level languages in game development has been on the rise for several years. This book serves as the ideal manual for those who wish to learn to program games using high-level languages. It presents sample scripts and programming in a simple, straightforward way, organized in a reference-friendly manner. Python, Ruby, and Lua are being used in game production at major companies (Disney, Humongous, and Bioware included). Some popular games using these languages include Alice, Impossible Creatures, and Baldur's Gate. The CD will include all source code from the book, at least one complete open source game engine for each language, compilers for each program, the HAP debugger, the Twisted Framework, libraries, and plug ins. ... Read more

Customer Reviews (7)

Why 3 languages?
I had assumed that I would be reading a book about combining the 3 languages to create a game.First I wanted to know why.I was distracted by the Pygame section, as I've been readingBeginning Game Development with Python and Pygame: From Novice to Professional.In comparing just the Pygame coverage, Beginning Game Development with Python and Pygame is 20x better.There is no reason to have Game Programming with Python, Lua, and Ruby.There isn't sufficient enough coverage on any one language to get a grasp, and if you're already familiar with one or all of the languages, you have to wade through all the newbie stuff to get to the meat.Where is the bibliography?The author describes several facts with no evidence such as a bibliography would provide.

Thanks
This book didn't have what I was looking for but it was exactly what I ordered and it arrived in great condition, Thank you.

Game Programming 500 page overview
As previously mentioned, the book is basically an overview.
However, it did assist me when I was researching a choice for a programming language (Python).The book shows the pro's, con's, and example syntax which is its best point. The book also mentioned successful projects using a particular language.I was able to check out this book at CompUSA before they closed.I cant recommend purchasing the book for more than a few bucks, but it would be worth a trip to the library or ebook view. You could get the same results by using Wikipedia.

nothing about how to program the game itself
Its really a shame that most beginning game programming books use C++ or some obsure languages like unheard of flavors of BASIC and ignore the prevelence and ease of use of modern scripting languages. This book is not for beginning programmers, it just introduces these 3 scripting languages and then throws some game code in the back of the chapter for each.

An Absolute Joke
First let me preface this by saying that i'm only on page 31 and ALREADY am I compelled to write a review about how bad this book is. however, if I get further into the book to find that by some miracle it actually improves, I will revise this review as appropriate. However, the first 31 pages alone are so bad i had to say something before other people blow their cash on this.

Where to begin? I suppose my biggest problems with the book are:

1) It's like no one edited the book AT ALL:
By only page 31, already i've had to re-read more than a few sentences because of the blatant grammar errors that I simply don't expect when reading a professionally published book, such as

"A strings is basically..." (p31)
"In the1960's software development..." (p13).
"They can be composed numbers, letters..." (p30)

There are numerous others but I can't remember them off hand.

Also, in Chapter 1 as the three languages are introduced, the author produces a diagram for each language's "family tree". Two out of three of these are completely wrong. Figure 1.5 is labeled as "The Python language family tree", yet the diagram itself doesn't contain Python anywhere-- rather, the root of the tree is Lua. Figure 1.6 is labeled "The Lua language family tree", but again, Lua is nowhere to be found; rather, the root of the tree is Ruby.

How can so many errors exist already, less than one TENTH of the way through the book?

2) Numerous technical errors and misconceptions:
With all due respect, I seriously question the author's grasp of even basic subjects so far.

For instance, on page 25, we're told that the # symbol is used for one-line comments in numerous languages, including *C*. As anyone with even a semester of junior college CS classes knows, the # symbol denotes a proprocessor directive in C, not a single-line comment. This would be nitpicking anywhere else, but in the context of a professionally published book, especially one that's already on such shakey ground, this is unnerving.

On page 18, one of Lua's features is described as the ability to be compiled into byte-code, "simulating a virtual machine". "Simulating" a "virtual" machine? In other words, Simulating a simulated machine. You don't simulate VM's-- the whole concept of a VM is a simulation in the first place. It'd be like "simulating" virtual reality. Again, it wouldn't normally be a big deal, but I can't help but wonder how much the author really "gets" this stuff. This becomes less of a joke when you consider genuine newbies reading this stuff, setting them up for real long-term confusion.

There are other examples but those are two I remember off the top of my head.

3) A book clearly aimed at no one:
This book, as I understood it at least, is aimed at game programmers who want to learn how to use scripting languages to either script their games, or implement their games while using native languages like C++ to handle performance-critical elements such as graphics.

Unfortunately, it also seems to be aimed (in certain parts) at newbies and flat-out non-programmers. On the one hand, the author has gone out of his way to explain what CPU is (!), what commenting is (!), and how parentheses are used to denote order of operations in math expressions (!). Not more than a few pages later, however, we get this sentence (typo taken from actual text):

"[Lists] can be composed numbers, letters, or even constructs such as arrays, hashes or even other lists." (p30)

Exactly what type of reader needs to be told what CPU stands for, what a comment is, and what parentheses mean, but has no problem following along when you mention "constructs" such as arrays and hashes?

My point is that the author is continually wasting time with useless explanations of things that would only serve a *brand new* programmer who knows virtually *nothing* about computers or programming in general. Needless to say, that person simply won't learn anything from a book like this, which would clearly only be useful to an intermediate programmer or better (so far at least). So those of us actually trying to learn something have to sit through these absurd sidebars and tangents instead of focusing on what we came for. Of course, if you actually were a total newbie, you wouldn't be able to understand 90% of the content *aside* from these useless sidebars and tangents.

4) Strange organization:
I'm only about 7 pages into Chapter 2, and I'm already about to give up on this book. This chapter is an absolute train wreck and is the total opposite of the approach that would have worked. Believe it or not, the author is attempting to introduce all three languages, Lua, Python and Ruby, *simulatneously*. In some ways this sounds like a decent idea, since it seems like it would allow the reader to directly compare the languages feature-for-feature. Unfortunately, keep in mind that this book is designed to *teach* these languages, not just compare them. Imagine having to learn three separate topics at one time simply because later on, you'll have to chose one of them to go with. I've never read anything so disjointed in my life. Fortunately, I already know a thing or two about two of these languages, so I can keep my head above water, but it's obvious that if I didn't understand any of them I would be totally lost.

This book is begging to be rewritten in a straightforward divide-and-conquer approach. Teach me things in separate, discrete, understandable chunks, and THEN tie them all together and make the necessary comparisons. Throwing them all into a single chapter TOGETHER makes things endlessly confusing for no reason whatsoever.

5) A weird, sketchy writing style overall:
Lastly, and I admit I don't know quite how to categorize this, the author writes in a style that is just bizarre. Overall, it often sounds like I'm reading a conversation between one beginner-level programmer trying to explain programming concepts to another beginner. Ugh:

- "Variables are holders for data any computer or program might need to use or manipulate."

I know what he's trying to say, but this is a REMARKABLY obtuse way of saying it. "Any computer or program"? "Use or manipulate"? Yeesh.

- "Variables are usually given names so that a program can assign values to them and refer to them later symbolically."

"Usually" given names? That's like saying numbers "usually" have values. And the program doesn't "assign values" to those names-- the programmer does. Variables exist *solely* for benefit of a human programmer, not an executing program. Variables and their names (generally) do not persist beyond the compilation stage, and even when they do (as in the case of late binding or debugging), they still exist for the use of the human programmer only, not the "program". Explaining this concept in such a hazy and clearly incorrect manner is poison for a beginner's understanding.

- "Another commonality between Python, Lua and Ruby is using parentheses() to state precedence;"

This may be true, but why phrase it this way? It implies that the parentheses is a specific feature to these three languages. In reality, the only mainstream alternative to parentheses is RPN, which is used virtually nowhere in modern programming languages. Parentheses are a de facto standard among all high-level languages if ever there was one, not a "commonality" between these three languages. He might as well say the same thing about variables, conditional logic, iteration, and what have you.

To sum up, this is a book that doesn't have a clearly defined target audience (by a long shot), is written in a savagely unprofessional and often baffling style, and is riddled with subtle and not-so-subtle mistakes and innappropriate tangents.

The only reason I've written a review so early into the book (page 31!) is that I'm already thinking about returning it, and want to make sure others have some idea of what they're getting into before they buy it. At best, if you're still curious, give this thing a good 30 minutes at least in your local bookstore, and keep an eye out for the things I mentioned.

The Premier Press GameDev series actually does have a lot of good, underrated titles, and gets a bad rap more often than it deserves, but books like this definitely aren't doing it any favors. ... Read more

Product Description
Python for Software Design is a concise introduction to software design using the Python programming language. Intended for people with no programming experience, this book starts with the most basic concepts and gradually adds new material. Some of the ideas students find most challenging, like recursion and object-oriented programming, are divided into a sequence of smaller steps and introduced over the course of several chapters. The focus is on the programming process, with special emphasis on debugging. The book includes a wide range of exercises, from short examples to substantial projects, so that students have ample opportunity to practice each new concept.Exercise solutions and code examples are available from thinkpython.com, along with Swampy, a suite of Python programs that is used in some of the exercises. ... Read more

Customer Reviews (4)

A good introduction to programming using Python
Allen Downey's "Python for software design" is a major revision of the author's earlier work "How to think like a computer scientist", and is intended as an introduction to software design using the Python programming language.

The Good: this book is easy and fun, just like Python itself. The author uses clear language, defining each new term as soon as it appears, and then gathering all the definitions in a glossary at the end of every chapter. The book is approximately 250 pages long, consisting of 19 chapters. Each of these is about ten pages long. Most chapters focus on elements of the language (e.g. functions, strings, tuples, inheritance) while a few of them are "case studies" which use the material introduced up to that point. Chapters are subdivided into at least 10 sections each, the last of which is always the exercise section. The author has provided solutions to some of the exercises on his website, where the interested reader can also find the example code used in the book, swampy (a suite of Python modules the author has written), as well as the complete text of the book (available for free). Toward the end of each chapter and in an appendix, Downey has provided material on debugging. These sections often provide him with an excuse to offer advice on programming best practices.

The Bad: classes and objects are introduced in chapter 15 (of 19). There are those who might think that such a chapter structure leads the reader to undervalue object-oriented programming. However, given the book's intended readership, I don't think this is a particularly egregious error. The question of the readers's required background (or lack thereof) is also connected to the choice of topics covered in this volume: since this is an introduction, many things are obviously left out (e.g. there is nothing on generator functions, lambda expressions, binary data, destructors, metaclasses and so on). Once again, this is unavoidable in a short book intended for people with no programming experience. Finally, with the exception of a few footnotes, this book describes Python 2.x, not the (backward-incompatible) Python 3.x. However, this is also the case for the majority of the good Python books out there, and for third-party software, so Downey's decision seems reasonable.

Taking the book's earlier title (which is now its subtitle) to heart exposes it to comparison with heavyweights claiming to be filling a similar niche: a) "Introduction to programming in Java: an interdisciplinary approach" (Sedgewick & Wayne), b) "Python programming: an introduction to computer science" (Zelle), and c) "How to Design programs: an introduction to programming and computing" (Felleisen, Findler, Flatt, & Krishnamurthi). The latter uses Scheme, following the classic volume "Structure and interpretation of computer programs" (Abelson, Sussman, & Sussman). All of these books are arguably deeper than "Python for software design", but it is important to note that they are also longer and more difficult to read.

In a nutshell, this book is optimal for high-school or college students making their first foray into programming. Such readers would benefit most from buying the paper copy and trying to do most of the exercises. The book might also prove useful to experienced programmers who are interested in an easy, idiomatic, and concise introduction to many aspects of Python.

Alex Gezerlis

learn python
It's excellent for what it covers. I don't know if it's just me or not;but
I found that some of the exercises were too difficult too early.Otherwise,
the methods used to instruct were quite good.

Good for teaching
I'm using this book to teach my (homeschooled high school sophomore) son programming, and it is working very well.It teaches programming basics, some computer science and software design, and debugging using Python.Unlike some others I glanced at, it is mercifully brief.It has solid exercises with online code solutions as well as modules to get up and running fast (swampy is fun) -- they can be easily supplemented with exercises from my son's math and physics texts.The author gets into some substantial topics early (like recursion) that have kept us challenged even in early chapters.I was a bit apprehensive about launching in to Python since I have never studied an object oriented language (my programming experience is dated by about 25 years), but the text is clear and Python is fun and accessible.

While I appreciate the author's emphasis on debugging, I think he goes into more detail on debugging than is useful at this level.That is, the exercises are not difficult or involved enough to practice the debugging strategies that he teaches.He is an experienced teacher, however, so perhaps his ounce of prevention will save students trouble down the road.You might want to consider a supplemental text that is more reference-oriented.

Excellent Introduction to both Python and Computer Science
This book fills a niche that few other Python books can fill: an introduction to Python that also gives a strong introduction to computer science and software design.

I have read many Python books aimed at students in Computer Science that are little more than translations of a previous book into Python.Many of those books are full of "non-Pythonic", unintuitive, or erroneous code.This book makes none of those mistakes.In a relatively small package it still manages to give a firm foundation in writing concise and efficient Python programs.Chapters are written around Python's basic data types and quickly show the correct way to use these structures.

The case studies included are excellent and get students involved with graphics early in the book--with help from the Swampy module.Other case studies show how easy it is to use Python to parse text files and write functions for lexicographical analysis.After covering the basic types (including files and modules), Downey moves on to object-oriented programming and wraps up the book with a look at Graphical User Interface (GUI) programming in Python.

This book is well suited to individual study, but I use it in a high school Computer Science course.I find this book to be much better than most textbooks aimed at introductory computer science students.This book compares well with the classic Python Programming: An Introduction to Computer Science [With CD-ROM] [PYTHON PROGRAMMING]. ... Read more

Product Description
Python: Create-Modify-Reuse is designed for all levels of Python developers interested in a practical, hands-on way of learning Python development. This book is designed to show you how to use Python (in combination with the raw processing power of your computer) to accomplish real-world tasks in a more efficient way. Don't look for an exhaustive description of the Python language––you won't find it. The book's main purpose is not to thoroughly cover the Python language, but rather to show how you can use Python to create robust, real-world applications.

In this respect, the goal is similar to foreign-language books that identify themselves as “conversational,” focusing on the vocabulary and concepts that people will need the most. Likewise, I focus specifically on the Python knowledge needed to accomplish practical, specific tasks. Along the way, you will learn to create useful, efficient scripts that are easy to maintain and enhance.

This book is for developers with some experience with Python who want to explore how to develop full-blown applications. It is also for developers with experience in other languages who want to learn Python by building robust applications. It is well-suited for developers who like to “learn by doing,” rather than exploring a language feature by feature. To get the most out of the book, you should understand basic programming principles.

Because this book is project-based, you can approach it in numerous ways. You can, of course, read it from cover to cover. Chapters 2 through 8 each cover a different project, so the chapters are independent of each other. However, because each chapter project is covered individually, there may be some overlap of information. I also sometimes refer to explanations of particular topics covered in previous chapters. This will help to reinforce important concepts.

The end of the book contains two appendixes. The first one is a listing of Python resources you can check out for more information. The second one will help you with installing additional components used in some of the examples.

This book starts with a basic overview of the Python language, designed for those familiar with other languages but new to Python. It is followed by several chapters, each of which describes a complete project that can be used as-is or modified and extended to suit your particular purposes. You'll find applications that access databases, take advantage of web technologies, and facilitate network communications, to name a few. In addition, and more important than the technologies you will be introduced to, you will learn how to use Python to solve real challenges. Following these chapters are two chapters that cover accessing operating system resources and debugging and testing, respectively.

Each project chapter contains complete instructions describing how to install and use the application, so you can actually see the program run as you learn how to construct and use it, including how the project was designed and prototyped. This book is intended to be both a reference guide and a learning aid, teaching you how to build solutions with Python and providing reference information on a wide variety of Python programming concepts.

It is hoped that this book will help you have fun with Python and build useful applications, and—unlike my experience with building a deck—without sore thumbs.

This book is framed around the code itself. This is because developers are typically looking for how to do something; and, as with many activities, you learn how to do something by watching how others do and trying it yourself. If you want to know how a for loop works, you'll find for loops in my code, but that's not the thrust of the book. Instead, this book shows you how to do things: how to build a content management system, how to build a test management system, how to set up a system for tracking customer follow-up, and so on. Along the way, you'll learn how to communicate with a SQL database, how to act as a web server or communicate with one, how to access operating system services, and more.

There are three basic components to the book:

• Chapter 1 is a brief overview of the Python language.

• Chapters 2–8 cover seven different programming projects, which illustrate various technologies and techniques available to Python developers.

• Chapters 9–10 cover additional, advanced topics, which will help you as you build Python projects.

The project chapters have a consistent structure:

• Overview: What does the application do?

• Using the program

• Design

• How it all fits together

• Modules involved

• Code and code explanation

• Module/class 1 explanation

• Module/class 2 explanation

• Minor code file explanation

• Testing, including suggested tests

• Modifying the project, including some suggested adaptations

• Summary

Each project is designed with classes that can be reused and accessed for multiple purposes. This is one of the main benefits of object-oriented programming, so designing for reusability is a main focus of the book. The book contains the following chapters:

1. Python Basics

This chapter is a basic primer on the Python language, and it functions as either a quick tutorial for experienced programmers new to Python or a refresher for programmers with Python experience.

Part I: The Projects

2. Directory/File Snapshot Program

This project demonstrates how to interact with files, create and manipulate data structures, and provide user output. It also touches on code design issues to improve code maintainability. Often when installing or uninstalling software, or verifying changes to a file system, it can be valuable to take a “snapshot” of the files and directories, along with their size and last-modified time. The script introduced in this chapter does just that. This chapter also explores how to capture a directory listing into a Python list, and explains how to query this list for particular values.

3. DVD Inventory System

This project takes advantage of Python’s capability to access and manipulate data in a SQL database. The application enables multiple users to log in to a website that provides access to a DVD inventory database. Permissions are set such that some users can add, modify, or delete entries, whereas other users have read-only access to the data.

4. Web Performance Tester

This project shows how to communicate with a Python web server and retrieve information regarding how long it takes to receive requested items from the web server. Although writing Python programs to work on a single computer can be useful, the real power of Python can be seen when it is used to script communication between computers on a network. Most networks contain several web servers. A nice feature of Python is that it can act as a lightweight server for various Internet protocols, such as HTTP (web) and ftp. This application enables you to monitor performance of HTTP traffic on your network.

5. Customer Follow-Up System

This project shows how to present a web form to the user and retrieve data from it, how to automatically format and send e-mail through an SMTP server, and how to generate an HTML-formatted report. The task for the second example is to automatically generate a customer comments e-mail message based on information the customer enters in a form. It uses the mod_python Apache module to take the information entered in the HTTP form and then utilizes a Python script on the web server to send that information to an SMTP server for mail delivery.

6. Test Management/Reporting System

This project makes use of the unittest module to run tests against an existing application, and creates a framework for reporting test results. Testing is a vital process for developing software. This application enables users to run tests for a given piece of software, to list the previous test runs by date, to show test run results for any previously run tests, and to output the results of any test run as HTML for viewing in a web browser.

7. Version Management System

This project connects to a list of servers via telnet, checks the application version of a pre-set application list, and displays its results both as output and to a log file. Often, a system administrator needs to patch systems or ensure that systems have the latest application versions installed. This script is an easy way to accomplish that task. It makes use of Python’s capability to emulate a telnet client and log in to remote systems and perform functions on that remote system.

8. Content Management System

This project explores Plone, a popular content management system based on Python and Zope (a Python-based application server). Because Python is a very mature language, numerous applications have been built on top of it. A great thing about working with Python-based applications is that you get the benefit of a full-blown application but you can still use Python to configure and customize it.

Part II: Advanced Topics

9. Interacting with the Operating System

When writing scripts “in the real world,” often it is critical to be able to access services available through (and particular to) the operating system you happen to be on. For example, suppose you wanted to read or modify the Window Registry? Or you wanted to get the Linux process ID of a particular process that is running? Is such a thing even possible? Definitely—and this chapter shows you how.

10. Debugging and Testing

Because I am a software tester myself, testing is a subject that is certainly close to my heart. In... ... Read more

Customer Reviews (5)

Broad overviews
This is not a bad book, it just isn't a book for beginners. There is not a whole lot in the way of troubleshooting and if something that the book has you do does not work you more or less have to hack the code together yourself to get things off the ground. The community site that partners with this book and others in the series is a wasteland really. It doesn't seem to be active with many of the forum section completely barren and the forums sections with discussions have been inactive for several months if not years. In other words don't expect a whole lot of support from anywhere regarding what you read here. All in all though the book does have some interesting coding and can really help broaden intermediate coders perspectives on how to code in Python.

Wanted to like this book but just couldn't
I really wanted to like this book.As a professional C# developer, I have been learning Python the last few weeks.I got this book in hopes that it would provide some interesting projects.

I could not bring myself to like this book.It was a painful read because this book demonstrates poor and obsolete programming practices.I feel like this book would probably set a beginner back instead of helping them move forward.I would recommend almost any other Python book over this one.

The book does have seven fairly interesting projects, covering a wide breadth of the Python standard library (xml parsing, database access, file input/output, etc) and some web-based projects.That is why I wanted to like it.It covers interesting topics.However, this is not enough to make up for the sloppy editing, obsolete user interfaces, and poor programming practices.I will detail some of the problems below.

Sloppy editing - For example, look at the code sample at the top of page 31.This wouldn't even "compile" in Python's editor IDLE, because of the incorrect indenting.

....elif choice == "4":
........snapshothelper.showHelp()
.........else:
........if choice != "5":
............snapshothelper.invalidChoice()

The "else:" is intended wrong and then on page 32 the same code is excerpted except it has been copied incorrectly:
....elif choice == "4":
........snapshothelper.showHelp()
....else:
.........snapshothelper.invalidChoice()

You can see that the author corrected a mistake in the main block of code but then did not correct it in the excerpt.

This is just the tip of the iceberg for code blocks that will cause errors upon running them inside Python.

On to the next problem - The user interface for the command-line projects looks like something out of MS-DOS 3.1.In other words, it is extremely outdated, cumbersome and it's not even programmed effectively.The error messages are obtuse and don't even cover all the cases.Frankly, I expect a lot more from an author with an extensive background in testing.For example, in page 70, the "elif" block never checks for choices that are not 1 through 5.If you have an invalid choice it will cause a SQL error and print the error message "THERE WAS A PROBLEM MODIFYING THE RECORD" even though the error was caused by an invalid choice.

My final complaint is that the author does not follow Pythonic practices or even best practices from other languages.For example, the Try-Except blocks (page 79 for example) include large swaths of code instead of just the small section that will actually throw the exception.Also, the Except clause does not catch particular error classes but instead every error.These violate basic best practices for any language.Another example of not being very Pythonic is the lack of list comprehensions like on page 37 (also note that this sample includes inconsistent indentation and would likely cause the Python interpreter to fail):
....for item in filelist:
............if item.find(extension) != -1:
................snaplist.append(item)

This could easily be re-written in the Pythonic way:
....snaplist = [for item in filelist if item.find(extension) = -1]

Unfortunately, I could go on and on talking about things I don't like about this book.The bottom line is that I don't recommend it.

Learn Quickly by Doing
The approach that the book takes really caters to my learning style i.e. learning by doing. Normally the programs you write in IT books are useless but to my delight, most programs in this book (8 in total) have potential for immediate usage at home and at work, which makes it that much more rewarding to go through them.

This is a great way to quickly learn programming for those of you that already know some of the basics. I can't wait to see more books out of the "Create - Modify - Reuse" series.

The author also makes it really clear that the first examples are not optimally designed in order to keep things as clear and simple as possible - OOA&D snobs should look elsewhere. Besides, starting a little loose on encapsulation just affords more repetition to reinforce the key Python concepts.

Good for 2 days weekend to learn your new powerful language
Well, not that bad 1 star.

I've tried to find a book that teach me python about, command line interactive, file read/write, CSV & MySQL full application (not a GUI but in the console interactive).

All of the examples are using project as a guideline. The code is easy to follow and the author explain well (IMO, a bit too detail for the some same topic that no needs to explain)

So, in the nature of Python, we have to download additional libraries mostly. So, for most the code examples are work for me.

I'm happy about this book very much. SInce I'm looking for a book that can teach me Python in a few days and can read + understand how to use python in each project by reading the book mostly. So, I can now move to the more detail books like Core Python or Python in Nut Shell, etc.

What I would like the book to have is about using web framework like Django, TurboGears or Pylon. The book use Plone. No question about how good Plone is but the little chapter for it is too superficial for Plone and it can be read from many websites. So, I think it'd be a popular and more lightweight framework like Django, Pylon, TurboGears.

If anyone have a few days even far from your computer. You can learn Python easily by the book and for most programmer, it's no need to type (but recommend) since the book describe the code in detail.

Recommend for people who want to know python quickly. Then you'll jump to next Python books like me :-)

Mediocre book and poor accompanying source
I was very disappointed by this book.I have come to expect more from WROX than this.If I was given this book without a cover, I would never have guessed the title.The book is organized more like a cookbook of projects that each illustrate a particular point or technique than a book titled "Create - Modify - Reuse".

The source code in the book is broken into fragments and isn't usable by itself.You will need to download the accompanying source from the publisher to run the programs.Unfortunately too much of the downloaded source is broken and has to be fixed before it will run. The style and organization of the code reminds me of a first year student's programming assignment.

I'm just glad I only borrowed this book from the library and it had to go back anyway. ... Read more

Product Description
As Linux increases its presence throughout the world as atarget platform for professional application development, its growthas a powerful, flexible system offering many free development toolsassures its place in the future. By giving you easy access to thiscomprehensive range of tools, supporting new and nascent technologies,at little or no cost, developing with Linux allows you to apply thesolution that's right for you.

In this follow-up to the best-selling Beginning Linux Programming, youwill learn from the authors' real-world knowledge and experience ofdeveloping software for Linux; you'll be taken through the developmentof a sample 'DVD Store' application, with 'theme' chapters addressingdifferent aspects of its implementation. Meanwhile, individual'take-a-break' chapters cover important topics that go beyond thebounds of the central theme. All focus on the practical aspects ofprogramming, showing how crucial it is to choose the right tools forthe job, use them as they should be used, and get things right firsttime.

Who is this book for?

Experienced Linux programmers and aspiring developers alike will finda great deal of practical information in this book on libraries,techniques, tools and applications. You should be familiar with asimple Linux system, have a good working knowledge of programming inC, and a basic understanding of object-oriented programming with C++for the Qt/KDE chapters.

What does this book cover?