Google and YouTube use Python because it's highly adaptable, easy to maintain, and allows for rapid development. If you want to write high-quality, efficient code that's easily integrated with other languages and tools, this hands-on book will help you be productive with Python quickly -- whether you're new to programming or just new to Python. It's an easy-to-follow self-paced tutorial, based on author and Python expert Mark Lutz's popular training course. Each chapter contains a stand-alone lesson on a key component of the language, and includes a unique Test Your Knowledge section with practical exercises and quizzes, so you can practice new skills and test your understanding as you go. You'll find lots of annotated examples and illustrations to help you get started with Python 3.0.

• Learn about Python's major built-in object types, such as numbers, lists, and dictionaries

• Create and process objects using Python statements, and learn Python's general syntax model

• Structure and reuse code using functions, Python's basic procedural tool

• Learn about Python modules: packages of statements, functions, and other tools, organized into larger components

• Discover Python's object-oriented programming tool for structuring code

• Learn about the exception-handling model, and development tools for writing larger programs

• Explore advanced Python tools including decorators, descriptors, metaclasses, and Unicode processing

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 146 Ratings

Good book - 2009-10-02
Reviewer Rating:
It's a great book. I did buy a slightly outdated version, which was why it was under $6 (including shipping), but the basics are there.

Beginner programmers: This book is perfect. Though it doesn't have all the humor of a "For Dummies" book, it's not dry reading (IMHO).

Expert programmers: Don't buy this book for yourself; it's a little long-winded. You'll learn the language, but you'll also spend too much time reading about the concepts of programming...

Great for learning the CORE language ... - 2010-01-18
Reviewer Rating:


import my_four_recommendations:

from bookshelf import "Learning Python 4th ed. - by Lutz/O'Reilly", "Beginning Python from Novice to Professional - by Lie Hetland/Apress", "The Quick Python Book - by Ceder/Manning", "Python Programming on Win32 - by Mark Hammond"



############################
#Comparative overview
############################


I have the four books above. They all have their strengths and weaknesses, but are all of very high quality overall.
However the Lutz/O'Reilly book has more pages, and is more comprehensive, and is probably my favorite for learning the CORE LANGUAGE from straight beginner level. It can be verbose, and goes through every detail of the language, from the very basic stuff to the very high level stuff listing every sort of avenue/path you could potentially take in utilising the language, and explains it in very clear, plain and concise prose. Good examples after each instance of a new concept, and also examples of errors for illustration purposes if you were to not write the code in the right way is very helpful.

A detailed example would be the following on OPENING FILES. Here are three passages from each book explaining the same concept:

Lutz p.230-233 on "Opening Files":

###The Lutz book lists all filetype operations in a table first###

"To open a file, a program calls the built-in open function, with the external filename
first, followed by a processing mode. The mode is typically the string 'r' to open for
text input (the default), 'w' to create and open for text output, or 'a' to open for
appending text to the end. The processing mode argument can specify additional
options:
*Adding a b to the mode string allows for binary data (end-of-line translations and
3.0 Unicode encodings are turned off).
*Adding a + opens the file for both input and output (i.e., you can both read and
write to the same file object, often in conjunction with seek operations to reposition
in the file).
Both arguments to open must be Python strings, and an optional third argument can
be used to control output buffering--passing a zero means that output is unbuffered
(it is transferred to the external file immediately on a write method call). The external
filename argument may include a platform-specific and absolute or relative directory
path prefix; without a directory path, the file is assumed to exist in the current working
directory (i.e., where the script runs). We'll cover file fundamentals and explore some
basic examples here, but we won't go into all file-processing mode options; as usual,
consult the Python library manual for additional details."

#The Lutz book then shows three specific examples of opening files 'In Action'. These examples go on for about 1-2 pages after the initial opening paragraph as aforementioned above.

-------------------

Lie Hetland/Apress p. 255 on "Opening Files":

"You can open files with the open function, which has the following syntax: open(name[, mode[, buffering]])
The open function takes a file name as its only mandatory argument, and returns a file object. The mode and buffering arguments are both optional and will be explained in the material that follows.
So, assuming that you have a text file (created with your text editor, perhaps) called
somefile.txt stored in the directory C:\text (or something like ~/text in UNIX), you can
open it like this:
>>> f = open(r'C:\text\somefile.txt')
If the file doesn't exist, you may see an exception traceback like this:
Traceback (most recent call last):
File "", line 1, in ?
IOError: [Errno 2] No such file or directory: "C:\\text\\somefile.txt"
You'll see what you can do with such file objects in a little while, but first, let's take a look
at the other two arguments of the open function."

--------------------

Ceder/Manning p. 159-160 on "Opening Files":

"In Python, you open and read a file using the built-in open function and various
built-in reading operations. The following short Python program reads in one line
from a text file named myfile:
file_object = open('myfile', 'r')
line = file_object.readline()
open doesn't read anything from the file; instead it returns an object called a file
object that you can use to access the opened file. A file object keeps track of a file
and how much of the file has been read or written. All Python file I/O is done using
file objects rather than filenames.
The first call to readline returns the first line in the file object, everything up to
and including the first newline character or the entire file if there is no newline char-
acter in the file; the next call to readline would return the second line, and so on.
The first argument to the open function is a pathname. In the previous example,
we're opening what we expect to be an existing file in the current working directory.
The following opens a file at the given absolute location:
import os
file_name = os.path.join("c:", "My Documents", "test", "myfile")
file_object = open(file_name, 'r')"

###############

As you can see the Lutz/O'Reilly is alot more comprehensive when it talks about the core language, explaining in detail how the language works behind the scenes. The Lie Hetland book tries to be very brief and concise but more broad.
The Manning book is probably best for people who already know Python and are looking for a quick reference to rejog the memory, since it is condensed to the most important features, functions and concepts in Python.

I think the titles do a good job of representing each book;
"Learning Python" is meant to be for beginners learning the language thoroughly.
"Beginning Python From Novice to Professional" is good for those who want to go quickly from the Novice to Professional spectrum. Perhaps good for people with a good background in other languages.
And "The Quick Python Book" is probably for those who are well versed in other languages as well as know Python already.

################################################
#Advanced features not included in the Lutz book
################################################

The biggest drawback to the Lutz/O'Reilly book is that it doesn't include advanced modules like the 'urllib', 'csv', win32/COM and the 'xml' modules. These modules were specifically of interest to me, and I had to source that from the Lie Hetland/Apress book. (For more info on win32COM + Python, see Mark Hammond's book; "Python Programming on Win32).
The Lutz book seems more comprehensive on explaining the LANGUAGE and how to master it, whilst the Lie Hetland/Apress book does this also, but goes into the more advanced features of Python and its usefulness and power for the real world. For example there is more discussion on how best to make use of Python for your needs at an advanced level, like how to go about extending/implementing Jython, IronPython or the different GUI packages out there for use. Lutz' book has none of this in any detail.


"""
#Note:
If you're buying computer programming books, it makes more sense to buy it in digital form. As you can use the search function, as opposed to hardcopy where it's probably harder to search for specific terms and symbols that relate directly to your query/problem.

Another book you could look at that I have not used is Wesley Chun's "Core Python Programming" or Mark Summerfield's "Programming in Python 3". Summerfield's book is more recent in terms of the currency of the language, however Lutz' book reviewed here is more up to date in terms of publication.
"""

Comprehensive and easy to read - 2010-01-31
Reviewer Rating:
The book is a good introduction for new programmers. In addition it has references to other languages like C++ which makes the book exiting for more expierenced fellows. The book can be recommended equally for studying Python and as a reference book.

Great Intro to Python - 2010-01-08
Reviewer Rating:
I probably wouldn't recommend this book as your 'First intro to programming...' or anything, but for anyone with moderate exposure to programming or scripting that really wants an indepth introduction to Python, this book is great. (and it would work for a dedicated beginner; it isn't terribly advanced, it just doesn't show enough programs IMHO to suit a beginner that wants to start 'doing stuff').

If you aren't sure you want to learn Python, go work through a web tutorial first and make sure you like it enough to commit to such a large tome (the one at [...] is a fine intro). That's what I did. When I wanted more, I turned to this book and could not be happier.

For serving its purpose though, I give it Five Stars.

It could have used some more examples, but that is what 'Programming Python' is for...
It could have used some reference lists, but that is what 'Python Pocket Reference' is for...
(I wouldn't want to have to carry this thing around with me for reference anyway!)

As far as a very thorough discussion of the basic language features of Python 3 (and 2.6, with differences pointed out), I felt that I got more than my money's worth out of this book (and went out and bought the other two companion books after reading this one and enjoying it so much).

I feel that I got a more thorough introduction to Python from this book than I received from a semester long C++ class with a slightly larger textbook, and I was able to go back and easily rework all my C++ assignments in Python after I finished (granted, Python made some but not all of them trivial). And it also left we well prepared to knock out a number of problems on [...] once I finished (granted a lot of them test your math more than your programming, but still).

After finishing those tasks, I am looking forward to reading through 'Programming Python' and getting a better introduction to the library.

Very good - 2009-11-29
Reviewer Rating:
This is an excelent book if you want to learn about the Python language. I recomend!

Browse Similar Topics

Top Level Categories:
Programming

Sub-Categories:
Programming > Python