Python 3 for Absolute Beginners (Expert's Voice in Open Source) [Paperback]

Tim Hall (Author), Stacey (Author), Swaroop C H (Author)

Book Description

ISBN-10: 1430216328 | ISBN-13: 978-1430216322 | Publication Date: October 29, 2009 | Edition: 1

No previous experience required! Python 3 for Absolute Beginners is the book to bring out the hidden programmer in all of us. Using a unique, non-nonsense, jargon-free approach, the author provides readers with an absolute beginners guide to writing useful scripts, extensions and programs in Python 3.

Editorial Reviews

About the Author

Tim Hall currently provides front-line support for 64 Studio. He has also written newbie tutorials for Linux User & Developer magazine in-between more mundane system admin and web authoring jobs.

Tim has released albums and performed as a musician and songwriter, both solo and in collaboration with other artists. He has been further honored as the holder of the Bardic chair of Glastonbury between 2005 and 2007.

Tim uses Python as his main programming language, primarily as a means for creative ends, because it is easy to read and fun to learn.

Product Details

• Paperback: 312 pages
• Publisher: Apress; 1 edition (October 29, 2009)
• Language: English
• ISBN-10: 1430216328
• ISBN-13: 978-1430216322
• Product Dimensions: 9.3 x 7.5 x 0.9 inches
• Shipping Weight: 1 pounds (View shipping rates and policies)
• Average Customer Review: 3.7 out of 5 stars  See all reviews (7 customer reviews)
• Amazon Best Sellers Rank: #739,563 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

29 of 34 people found the following review helpful:

1.0 out of 5 stars Not a Good Learning Guide for "Aboslute Beginners", December 26, 2009

By 

Plabius - See all my reviews

This review is from: Python 3 for Absolute Beginners (Expert's Voice in Open Source) (Paperback)

I awaited eagerly for the publication of this book. I had high hopes for it, but those hopes were dashed. This book suffers from three failings - the first of which is trivial, but annoying and confusing; the second is more problematic, and annoying and confusing; and the third is simply fatal. For an "absolute beginner" book, it fails not because it expects too much, but because it accomplishes too little.

First: The principal author, Tim Hall, is British. Because of this, he employs the Metric system in some of his code snippets, and the spelling used by speakers and writers of English in the United Kingdom. Now in and of itself, there is certainly nothing wrong with this; however in a book sold here in the USA, it is confusing. For example, on p. 43, the author begins to develop an application that is intended to calculate how much fabric will be needed to make curtains, depending on measurements input by the user. The measurements that he uses are given in centimeters and meters. Here is the US, however, fabric (from clothing to drapery to upholstery) is measured in inches and yards. Indeed, with the exception of the sciences (and to a lesser degree, a few others), we use the Imperial system of measurement (eg., pounds instead of kilograms, yard rather than meter, and quart instead of liter -- though that last one is becoming more common). In addition, the author uses both the American and British spelling of words. For example, on p. 44 he spells the word "meter" both as "meter" and as "metre"; and on p. 93, he spells the word "armor" as "armour". This is essentially trivial, but confusing and annoying.

Second: The book is riddled with examples of poor editing. For example, in versions of Python prior to 3.0, displaying text on the screen was handled by the print statement:

print "Hello, World!"

But in Python 3 and higher, the print statement no longer exists, as it has been replaced by a print function. Thus, the previous must be typed as:

print("Hello, World!")

In the first half of the book, however, the print statement appears more often than the print function. This is a problem because use of the print statement raises an error that causes the program to crash.

Lastly: The most serious failing of the book, unfortunately, is the poverty of the pedagogical technique employed by the author to teach programming. The author spends much more time covering version three of the Python language, and "professional" coding practices, than he spends actually teaching the reader how to program a computer with them. This is like teaching someone how an automobile works, or how to design one, without teaching someone how to drive it.

Many elements of the language are introduced, but we are given very little opportunity to practice programming a computer using them. No programming exercises are given during the course of reading the chapters, and none are given at the end of the chapters. Instead, the author introduces programming elements, shows their use as if the reader were typing them in a (Unix type) console himself, and then employs them in very large program toward the end of the chapter, one that he has written himself. There is no incremental building of knowledge and understanding through programming practice and experience, so the end-of-chapter program is a grievous labor to read through and understand.

For example, near the end of chapter five, there appears a program that covers six pages. It's a character-based roll-playing game of which the author, himself, says, there are "Limitations: Too many to mention." (p. 93). By the time you have finished typing in the code, much of which you will not understand unless you have a photographic memory, you're exhausted and your fingertips are numb! And when you have run the program, what you get in return for all of your efforts, is both disappointing and depressing. Following the program's listing in the book, the author briefly discusses some of the kinds of changes that you can make to the program, and suggests that you consider doing so, but he doesn't discuss precisely what or how. Furthermore, the roll-playing game was so completely uninspiring, that I felt no motivation whatsoever even to look at it again, let alone attempt to improve it. In chapter six, the author introduces more elements of the language, works them into the same roll-playing game, increases the amount of code to type in, and yet, produces the same results: an uninspiring and useless program that by now, you are beginning to despise.

The end-of-chapter applications are quite large, and this is precisely the problem. Essentially, this is because you are trying to run before you have learned how to walk, and to walk before you have learned how to crawl.

Conclusion: The first two problems that I discussed would be solved simply by a corrected editorial reprint of the book. The last, however, would be solved only by a complete rewrite of the material. The author is very enthusiastic about what he is doing, and I got the impression that he is an excellent computer programmer; unfortunately, being a good computer programmer is not the same as being a good teacher. And because the author is a poor teacher, you will not very well learn how to program a computer from reading this book.

As an alternative, I recommend Head First Programming: A Learner's Guide to Programming Using the Python Language, by Paul Barry and David Griffiths. Although this book uses Python 3, it isn't designed to teach the Python programming language; rather, it is designed to teach you how to program a computer (via Python 3), and their technique is excellent! Learning how to program a computer is what an absolute beginner is supposed to be doing. Programming concepts are language independent. The authors chose Python because Python makes learning (and implementing) programming concepts easier than other languages. Another very good one is, Hello World!: Computer Programming for Kids and Other Beginners, by Warren and Carter Sande. This book uses Python 2.5.1, so you won't become familiar with Python 3.x. The good news is that the author has a very good understanding of how people learn and he also knows how to teach.

3 of 3 people found the following review helpful:

5.0 out of 5 stars Excellent beginners book, April 2, 2010

By 

Anton Piatek (England, UK) - See all my reviews

This review is from: Python 3 for Absolute Beginners (Expert's Voice in Open Source) (Paperback)

Python 3 for Absolute Beginners, Tim Hall and J-P Stacey, Apress (ISBN: 978-1-4302-1632-2)

Disclaimer: I was asked to review this book through the Hampshire Linux User Group. I did not receive any instruction for the outcome of the review nor any payment for the review (though I did get to keep the book).

I believe it is important to know something about a reviewer of a book, so that the statements made can be fully appreciated. I am a Software Developer, so spend most of my day reading and writing code. These days it is mostly Perl and Java, though some days it is all C++. I have never written Python before, though I have poked at about two scripts (and even made a fix to one), but it is probably fair to say that I have spent less than an hour looking at Python code before reading this book.

The book does actually mention that the source code examples are available for download from [...] however it is mentioned on the first inside page where all the copyright information is (and which you normally skip over automatically). If you want the exapmles, they are at [...]

The book opens fairly well for a beginners book, and seems strongly aimed at someone who has never programmed before (I have heard lots of people recommending Python as a good language to teach yourself programming with and can understand why). I was pleased to an early reference to Monty Python as well, as this is where the name Python comes from.

The use of Python's interactive interpreter is excellent and it makes for great examples of simple parts of the language, while also being so short that you actually want to type them into your computer and try them out! In particular the author's use of Pythons interpreter to print out details of a data-type or variable, and even the outcome of comparisons (e.g. entering "1==2" into the Python interpreter returns "False" without having to actually use a print statement or any other debug methods which I think is fantastic for a new programmer and a real time saver)

It is a shame that the author fails to stress the differences between Python 2.x and 3.x strongly enough. While some code will work on both versions, there are very large changes and it should have been made more clear early on that Python 2.x code is unlikely to work in Python 3.x, and vice-versa, as I would expect users to also seek examples on the web and it will just be confusing if the examples don't work because of changes between versions of Python.

By chapter two some software design principles have been introduced alongside the first actual program, which is of course "hello world". The author spends a long time talking about Software Engineering and Design principles, which is all valuable information, but I doubt many readers will actually spend time reading this and will instead skip over it. It does cover pretty much everything from design approaches (inside-out vs top-down) all the way to code control, versioning, comments, documentation, etc so certainly tries to cover all the bases.

The book then moves on to explaining variables and datatypes, operators and precedence, integers vs floats and all the core basics of a language. I initially thought that explanations of Octal and Hexadecimal values were perhaps a little advanced for a book aimed at "Absolute Beginners", but the author did make a good point that these are often used in file permissions and html colours and this makes them very useful to know.

The examples in the book start off short and sweet, but at some point the author had the idea to continually rework a text-based RPG game he invented for the book. The only problem with this is that you end up staring at several pages of code, and all you want to do then is skip over it, and then start skipping the explanations of this long code. I think the author was trying to teach some good refactoring techniques throughout the book by using this larger piece of code, however I feel that shorter, separate examples would have been easier to understand.

At one point the example programs start using '#! /usr/bin/env python' as the first line of the code but without any explanation. My personal opinion is that '#!/usr/bin/python' is more common however even that has its problems. As Python 3 is still very new, pretty much all current Linux systems will have Python 2.x installed as /usr/bin/python so both of these methods would attempt to run the code with Python 2.x and not 3.x. Many of the example source files from the website are also the same, and because they do not define python3 as the interpreter via the hash-bang (#!) line they will not run if you just try to execute them, which is a real shame. Some of the downloaded source code gets very close with '#! /usr/bin/env python3.0', however on Ubuntu Karmic the current Python 3.x version is 3.1, so this code still fails to run unless you explicitely call it with Python3.1 or edit the line to just have "#!/usr/bin/env python3' which is symlinked to 3.1 Some of the short examples, particularly around regular expressions, refer back to variables that were last shown to the reader four or give pages previously. This makes it very hard

Other than the above minor problems with the book, it makes a very thorough introduction to programming and Python 3. If you have never programmed, then this is a very good book to start with. If you have programmed, but never in Python then this book is still very good, though you will find yourself skipping sections here and there. If you already know Python 2.x then this book is probably not for you, as it only explains a few changes between version 2.x and 3, and you will probably know the rest already.

One thing to mention is that Python 3 is still very new, and in fact 2.6 is the default for the Ubuntu Lucid Lynx release as well as (at this stage) Debian Squeeze. I expect Python 3 is still a few good years from becoming the default - This is either a good thing as you have more time to learn version 3, or it can be seen as a bad thing as most existing code is based on 2.x and will need quite a bit of changing to work in version 3 (and vice-versa).

[ review originally posted at [...]]

3 of 3 people found the following review helpful:

3.0 out of 5 stars Not terrible, but you'll probably need additional material with it, March 16, 2010

By 

Robert P. Beveridge "xterminal" (Lakewood, OH) - See all my reviews
(HALL OF FAME REVIEWER)    (VINE VOICE)    (REAL NAME)   

This review is from: Python 3 for Absolute Beginners (Expert's Voice in Open Source) (Paperback)

Tim Hall and J-P Stacey, Python 3 for Absolute Beginners (Apress, 2009)

I read this as part of my research on which web-centric Linux programming language I wanted to adopt for a couple of major projects I'm working on. As I ended up settling for Ruby, despite the incredible annoyance that is dynamic typing, you can probably infer some of what I thought of this book. That said, many of the shortcomings that caused me to reject Python are in the language itself, not in my choice of reading material.

The pros of Python 3 for Absolute Beginners: first off, the language Tim Hall uses. Hall is enthusiastic about programming, and it comes through without him ever talking down to the reader. Second, as the title tells us, this is a book for absolute beginners--not just those new to Python, but those new to programming altogether. Many programming books assume at least some familiarity with computers. This one does not. (That does, however, lead into a drawback or to, but we'll get to that later.) Third and last, the program that Hall develops over the course of the book is something that's at least the framework of something that would be real-world-usable: a fantasy combat game. Think swords, shields, and orcs and you're on the right track. Granted, in a book of this size (just shy of three hundred pages), not a lot is going to get done on such a thing. This is not at all the next Oblivion. But given that a lot of people who are just starting out in the programming world want to be game programmers, it's not a bad idea to start there.

And now the cons. First, and most importantly, the book's length, which I touched on in the previous paragraph. Most of the programming books I own are twice this length or longer. In fact, the longest single book I own is a programming book (thirteen hundred pages and change--Troelsen's overview of C# 2008). If you're going to use one program as a development tool, you need to give your book enough space to develop something that's really meaningful. No, not the next Oblivion, but at least something that's really playable at the end. I called it a framework in the last paragraph, and framework I mean. Perhaps he could've accomplished more if he'd approached it as a roguelike. Which brings me to the second pitfall: an almost complete lack of attention to GUI programming. The last programming book I read that didn't acknowledge GUI as the dominant computer paradigm was released in, if memory serves, 1994. Here we are fifteen years later, and Tim Hall is basking in the glory of the command line, with one (short) chapter that teaches us the basics of putting a box with a couple of buttons on the screen, though not how to wire them to anything meaningful. Third, the book could have done with another revision or two to update some of the code to the latest version of Python. It's not quite as bad a situation as I've heard said before, but there's definitely some 2.x code that made it through the editing process.

Usable, but you can probably find other, more detailed, books that will help you more. ***