Dive Into Python

AccordionGuy writes "If you've ever spent an afternoon in the "Computers" section of a bookstore going through the programming language books, you've probably noticed that most of them seem to exist only to boost a publishing company's fortunes by capitalizing on the hot new programming language of the moment. These books -- essentially glorified bookends -- seem to follow the same format, cover the same subjects and aside from the tiny flourishes that are part of each author's particular writing style, are indistinguishable from each other. Reading them, one gets the feeling that its primary purpose is to allow the author to make some payments on a car or mortgage. I have a few of these books and they're gathering dust on the bookshelf farthest away from my desk." For deVilla's review of Dive Into Python, a book that inhabits a completely different category, read on below. Dive Into Python author Mark Pilgrim pages 432 publisher Apress rating 9 reviewer Joey deVilla ISBN 1590593561 summary The "desert island" Python book

However, from time to time, you can find a programming language book that stands apart. You can tell from the way the author writes, the topics s/he covers, the unique presentation style and insight that s/he brings that the book is a labor of love. These books enjoy placement on the shelf closest to my desk -- that is, if they're not propped open beside my computer. Dive Into Python is such a book.

One thing that sets Dive Into Python apart from many other programming language books is that its author, Mark Pilgrim, didn't originally plan to make any money from it. As we often say in Open Source circles, he simply had an itch and decided to scratch it. Mark explains this in a story on his weblog in the form of a dialog between him and his manager after showing him a rough 20-page draft:

Manager: "This is really good. You could probably make some money off this someday."
Mark: "Maybe, but I'm not going to. I'm giving it away for free."
Manager: "Why would you do that?"
Mark: "Because this is the way I want the world to work."
Manager: "But the world doesn't work that way."
Mark: "Mine does."

First released in late October 2000 and published in online and downloadable forms under the GNU Free Documentation License, Dive Into Python had grown in fits and starts until 2003, when Mark declared the project closed. Even as an unfinished work, it was held in such high regard by the Python community that developers consistently recommended it; it was also included with ActiveState's Python and FreeBSD's ports distributions. When Mark announced that Apress had decided to pay him to finish the book and publish it, it became the most-anticipated book on Python ever. Even better, Apress has been gracious enough to allow Mark's world to work way it always has: Dive Into Python is still available for free download and is still under the GNU FDL.

What's in Dive Into Python

Many programming language books follow what I like to call the "Computer Science 101 Format", with the first few chapters devoted to covering basic concepts that any moderately experienced programmer already knows. Whenever I leaf through such a book and encounter a chapter that tries to reintroduce me to data types, looping or branching, I feel cheated; I'm essentially paying for a big chunk of book that I'll never read. If you've ever been annoyed by such filler, you'll find Dive Into Python a refreshing change. Rather than wasting time and trees devoting whole chapters to rehashing Computer Science 101, Mark chose to build each chapter after the first around a program that illustrates a number of Python features and programming techniques.

The programs upon which Dive Into Python's chapters are based strike a carefully-maintained balance. They are rich enough to illustrate a number of points and be the basis for some "real world" code, yet small enough to be comprehensible tutorials. For example, chapters 2 and 3 are based on "Your First Python Program", which is a mere six lines of code. However, in those six lines, you are introduced to function declarations, documentation strings, objects and their attributes, importing modules, Python's indentation rules, the "if __name__" idiom, dictionaries, lists, tuples, string formatting and list comprehensions. Within the first hundred pages, a point where many books are re-acquainting you with the "else" keyword, Dive Into Python covers the aforementioned topics as well as Python's reflection capabilities, list filtering, the "and-or trick", lambda functions, OOP and exception handling, all with enough thoroughness to be useful. After reading Dive Into Python, you may have trouble reading other programming language books because they'll seem glacially slow and fluff-laden in comparison.

For the first two-thirds of the book, Mark continues with this approach, presenting a program and then analyzing it to see what makes it tick, teaching Python and oftentimes a programming technique along the way. Each program covers useful tasks that you're likely to run into while programming and does so in an interesting way. At the same time, concepts are introduced in a way that makes sense. For instance, chapter 4 covers two topics that mesh together quite well -- exceptions and file handling -- and it does this by exploring an interesting application: a program that displays the ID3 tag information about each file in your MP3 collection. Later chapters explore regular expressions, HTML and XML processing and Web services. By the time you've finished the first two-thirds of Dive Into Python, you'll have been introduced to enough Python to start writing a wide array of "real world" applications. The book might have benefited from having a chapter covering database access, a task that's at least as common or as useful as accessing Web services, but that's a minor complaint.

While the first two-thirds of the book concerns itself with helping the reader become a Python programmer, the final third is about elevating Python programmers above mere competence. It covers useful topics (albeit rarely-covered in language books) such as refactoring and performance optimization as well as ones that may be new to even some experienced programmers: unit testing, functional programming and dynamic functions. Each chapter in this section is still based on an example program, but rather than analyzing a completed program, its evolution is traced. Although you can get by as a Python programmer without ever reading the material in this section, you'll be a much better one for having done so.

In keeping with the spirit of Python, Mark writes the chapters to present the material as completely and clearly as possible without extra clutter. If there's any additional material that doesn't apply directly to what he's trying to explain, he provides references or links to that material rather than attempting to "fatten up" the book.

The book's long gestation period, assisted by years of reader feedback and James Cox's editing has paid off. It doesn't have the rushed feel that many language-of-the-moment books have (especially the ones written by an army of authors, each one taking a chapter). As far as I know, there isn't any of the sloppiness that pervades many programming books these days, save one instance of the popular typo "teh" (and really, what truly 1337 book doesn't have one of these?).

Mark is aware that Python is likely not to be the reader's first programming language; it's more likely to be some descendant of ALGOL (or more precisely, a language that borrows heavily from either C or BASIC). He also knows that many programmers tend to misapply techniques from the languages with which they're familiar to the language they're learning. With these in mind, he's taken great care to introduce Python idioms as soon as possible. If you follow his advice, you'll be writing "real" Python and taking advantage of what the language has to offer rather than just writing Python-flavored version of whatever programming language you're most comfortable with.

Dive Into Python's Audience

The "user level" specified on the back cover of this book says "Beginner - Intermediate", which I feel is a little misleading. As I mentioned earlier, the book takes great care not to rehash topics with which programmers with some experience are already familiar and is written with the assumption that the reader is proficient in at least one object-oriented programming language. I think many programming novices would be overwhelmed with the speed with which Python features are introduced.

Experienced programmers, whether they are new to Python or are fluent with the language will benefit the most from the book. One programmer I know works with Python daily and and even submitted a patch to wxPython; even he said that Dive Into Python showed him things about Python that he never knew. If you're tired of books aimed at "Introduction to Computer Science" students, you're going to love this book. This doesn't mean that people who don't normally program can't benefit from the book: Joi Ito, who is a tech entrepreneur and not a programmer, learned enough from Dive Into Python to put together jibot, a bot for the IRC channel that bears his name. If you're new to programming, you might want to make Dive Into Python your second book or supplement it with an introductory text such as Apress' own Practical Python, O'Reilly's Learning Python or the free online book How To Think Like a Computer Scientist (the Python edition).

Conclusion

Dive Into Python may be one of the thinnest programming language books on my shelf, but it's also one of the best. Whether you're an experienced programmer looking to get into Python or grizzled Python veteran who remembers the days when you had to import the string module, Dive Into Python is your "desert island" Python book. If you're new to programming but have heard all the wonderful things about Python, make sure that this is the second programming book you read. My congratulations to Mark Pilgrim on an excellent book and authorial debut!

(Remember, you don't have to just listen to my effusive praise. Dive Into Python is available for free at diveintopython.org. Read it for yourself and if you like it, vote with your dollar!)

You can purchase Dive Into Python from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Comments

Finally!

[bblazer]

I have been waiting a long time ti find a book like this. It is a breath if fresh air. Similar (as far as fresh air goes, not writing style) to the Head First series. While the Oreilly 'animal' books take up most of my shelf space, this one will find a place there too.

Great Book

[wackysootroom]

It's the first thing I recommend to read after the official python tutorial to my co-workers who are just starting to learn python.

This book, Python in a nutshell, and the online python library reference are the 3 tools that I always recommend for python newbies

Not suprising; I hope the book's good

[Donny Smith]

If writing a book like that could get me $60K a year kind of job, I'd write one for free too.
(I hope the author makes enough money - I just want to point out a possible reason for doing that kind of thing).

From the article I noticed one interesting thing - his world didn't quite work out until that company chipped in some money for him to finish the thing.
The same is with music and software - if it weren't for companies and/or sponsors....

Just in case the site crashes, you should be able to get the book via eMule( "diveintopython" the current version is 5.4.)

Re:Not suprising; I hope the book's good

[janbjurstrom]

I guess you could see it that way. But I read his weblog semi-often, and from what I've learned, Mark did a sort of 'project house-cleaning' a while back (sometime after his marriage?). He talked about wanting to use his time in the most meaningful way, and therefore listed a few time-consuming things he would

a) stop doing altogether
b) keep maintaining but not work actively on
c) spend his 'new-found' time on.

I believe the Diveintopython project was put in group a). So IIRC this would mean that APress gave him an offer to finish it after he chose to abandon the project himself.

I could be mistaken but I'm too tired to check his site now.. You do it ;).

Re:Not suprising; I hope the book's good

[Jason Earl]

Dive into Python has always been a good book for some time now. The difference is that now it is available in a dead tree version, and it has had some professional editting.

His world worked out just fine. In fact, his free edition was good enough that he's getting paid to make a dead tree version while still giving away the electronic version.

It just goes to show that there is money to be made in this kind of stuff. Not huge piles of money probably, but enough to make it worth your while.

Re:Not suprising; I hope the book's good

[nessus42]

From the article I noticed one interesting thing - his world didn't quite work out until that company chipped in some money for him to finish the thing.

So? His world still worked out the way that he wanted it to. He still gives out the book for free if you don't want to pay for it. Proponents of free information have never said that the creators of the information shouldn't also be able to make money from it.

|>oug

a series of well planned coincidences.

[knowles420]

strange that this article should pop up today when just last night, i was digging through the local barnes & nobles looking for a good python book and went home with nothing more than another work of fiction.

i've been meaning to get further into computer programming than the basic knowledge i already have, and this book seems worthy of a purchase. i have suffered through quite a few "intro" books that do little more than teach how to code math equations and silly text manipulations.

what i am really in need of is either a series of problems to be solved (with solutions, natch) or a good book suggestion that actually makes me want to write programs.

the how-to books are easy, but i tend to get bored with huge compilations of instructions pretty quickly. perhaps what i need is a good "why-to" book. any suggestions?

Re:a series of well planned coincidences.

[claytongulick]

The "Why-to" question is the core of what separates good programmers from bad.

Inadvertantly, you question strikes to the core of modern IT, it is not language specific, but it is the root driving force behind all "geeks".

For too many people, the "Why-to" is "because I heard you can make lots of money as a programmer". To answer this demand, colleges and universities churn out rank and file incompetent and ambivalent programmers, weilding their Microsoft inspired toolchest of Visual Basic 6 or MS Access, they flood the resume pool, and pollute the code base with their lazy half-hearted attempts at development, causing project failures and frustration on a massive scale and dramtically increasing the costs of corporate IT.

These are the type of programmers who react with anger and fear when anyone mentions exploring different languages or technology. Who, when confronted with a problem or issue they don't understand are willing to shrug and say "I don't know" and pass the problem off to the true "geek" on the team.

On the other hand, you have the type of coder to which the "Why-to" question is like breathing... to whom coding grants god-like powers of creation, who is willing to stay up late solving obscure problems just for the rush of satisfaction when s/he gets the answer.

To this type of coder, the question is not so much "Why-to" but more, "How could I not?". Coding is not a job, it is a system of thought, the logical structuring of the chaotic real-world into discrete lines of code.

To this type of programmer, there is nothing more exhilarating than a new project, a blank file, a clean slate, from which they can craft the perfect solution. Starting from scratch and creating from nothing is the ultimate expression of their intellect, and they judge themselves critically by the result.

This is a quality that can not be taught in a univeristy, or measured by a multiple choice exam. These are the "basement geeks" who clutter their shelves with gadgets and obscure books.

They may have started on the IRC with the classic question "How do I make a game?", or as a sysop of a dial-up BBS who needed to add functionality.

The point is, for the true coder, the "Why-to" question was answered BEFORE the language question... they had some sort of need that could only be solved by learning to code... and after that they were hooked. They constantly evaluate new languages and more effecient/elegant methods of solving their problems.

There is no book that will make you _want_ to code, first you want to code _then_ you buy the book.

Asking "Why should I program?" is similar to picking up a shovel and saying "Why should I dig?". Unless you have a need, there is no point, and you will never understand why all those ditch-diggers keep debating the finer points of different shovels. You are out of context. For you, the answer is "You shouldn't".

That is, until you need a ditch.

Joy of programming...

[powerlinekid]

A few years back I needed to develop a program to download all of UserFriendly's archives (ok need is a strong word but thats not important). At the time I was familiar with the normal languages; java, C, C++, etc. I had heard about Python and figured this was something I could use to learn it.

I was blown away. Having never touched the language within a couple of hours of going through the online documents I had picked up enough to write the full script. Once that was done I didn't want to stop. I found Python to be an absolute wonderful language that made programming fun again. Since then I've written my fair share of Python apps to do nearly everything. Infact anytime I need a program that I can't quickly find or isn't out of it's realm, it gives me an excuse to use Python. A lot of the time I lookup a way to do something and sit there smiling to myself going "now thats freaking cool".

I haven't read this book, but from my experience Python is an awesome language. I'm sure the Perl people feel the same way about their language. To me Python feels clean, flexible and productive. Most importantly its fun.

Re:Joy of programming...

[Lodragandraoidh]

My language experience going back 24 years:

Basic, Fortran, Assembly (Intel and Sparc), Pascal, C, C++, Java, Lisp, shell(sh,awk,sed), Perl, and most recently Python. (roughly in that order; I saw some COBOL code once when a young programmer, but was immediately repulsed - thank heavens)

I actively use Perl and Python myself for everything now for several reasons:

1. All of the machines at my job (800+) are all preloaded with Perl - so I have to use it for automation (better than shell scripts particularly for mission critical one-off applications that have to be fault tolerant but deployed at the whim of our marketing and operations staff). If I didn't have to maintain Python myself on all of those machines, I would port everything over to Python in a heartbeat. However it took me 2 years to get management to agree to loading Perl in the first place - and there is no reason to incur the costs associated with validating a new scripting language for use in our production environment. So I live with it - and keep the footprint small.

2. For all other tasks - I use python.

Some neat things fall out of python that even as a neophyte I can appreciate:

a) clean syntax (if I only had all the time spent finding dangling semicolons in perl, I could take a sabbatical)

b) full featured web development tool (Zope - provides a framework for developing and hosting full service applications - designed to make building products to run under Zope easy - seperates the presentation from the logic using ZPT cascading style sheets and DTML for presentation, and python for the program logic [unless you are masochistic enough to depend upon DTML alone] - has a built-in database for managing Zope objects - and built-in httpd and ftpd servers - which can be further frontended using Apache as desired - can communicate with other databases [oracle, ODBC, postgreSQL, etc... many database plugins available] - has a large library of predeveloped products [modules for you perlmongers] that you can load and be up and running, or modify to your heart's content - and did I mention that its GPL'd?)

c) platform independent (just as with java and perl, python scripts can run without modification on many operating systems - keeping porting costs down to a bare minimum.

d) built-in documentation functionality - not as full featured as Perl's perldoc - but I might not have found the right product yet to do that (ideas anyone? or, is this a python project waiting for me to jump on - perhaps something that ouputs XML?)

The only drawbacks (and I use this term with trepidation - because they can seem positively refreshing after 10 years with perl) that I can see are:

A. Does not have the sheer amount of user contributed products (modules) when compared to CPAN^. Of course I wouldn't judge the quality of my carreer based on the weight of all of my program printouts either. Quantity does not equate to quality.

B. Slower than Perl and Java. Again, something I can throw hardware at to rectify. Squid goes along way to making web pages generate faster too - so you can ameliorate some of the problems without having to kill yourself.

C. Sometimes it takes longer to find resources online than with other languages because of the difference in popularity. However, the time spent needing to refer to reference material for Perl and Java is many times larger than the time spent doing the same with Python.

D. Because of my long experience with Perl, I find myself immediately jumping to a predetermined algorithm/function that is implemented differently in Python and thus create syntax errors in my code. This last is really a personal problem that time will erase.

My whole programming paradigm has changed. The advent

Python, prototyping, and gmailfs

[HungSquirrel]

The developer of gmailfs wrote it in Python. He claims it is his first jump into Python, and apperently he learns fast--two days from zero Python knowledge to a working prototype of gmailfs. Odds are decent that he learned from this book. If everything people are saying about Python is true, I might have to give it a go. I can already tell from Chapter 2 of this book that it's my kind of programming guide, so I shouldn't have any trouble.

Example 2.6

[Anonymous Coward]

Why is this example function named 'fib' when it computes the factorial of a number, not the nth fibonacci..?

Thoughts of Python...

[Golthur]

I wasn't a Python Zealot(tm) until I tried it... in fact, just the opposite.

When I heard about the whitespace-is-significant, I had nightmarish flashbacks of MVS JCL (thoughts of which still cause me to twitch uncontrollably). As such, I refused to even look at Python seriously for quite some time.

However, that being said, once I actually did get over my (admitted) prejudice and gave it a serious test - it earned an official "WOW", something which few languages have ever done for me. Never mind that I was as productive while just learning Python as I am as an expert in any of the other languages I use regularly.

Now, I'm an official convert. Python gives you all the tools you need, but never forces you to use the wrong one for the job.

All I need to do now is find a shop that actually uses Python...

Re:Thoughts of Python...

[iguana]

I use it daily in my job (http://www.mobl.com/handheld/cradles). Our test fixture (tests new boards coming off the line at our custom manufacturer) is written in shell scripts and Python on an embedded SiS-550 Linux board running 2.4.9, uClibc, BusyBox, etc.

I rewrote our Windows-based management tools into Python for myself. Using that protocol library, I've sent quick and dirty py2exe wxWindows programs to customers. "Just unzip and run." Unless they look closely, I'm sure they don't know (and don't care) they're running Python apps.

It's not exactly "in your face" like Zope but it glues together my day.

Re:Thoughts of Python...

[ashultz]

I tend to use emacs, which can handle indenting in any of twenty different ways, but anyway...

My conceptual problem is that when I cut and paste a block of code to a new place, there is no acceptible default indent level - I might want to end the previous block and start a new one, or I might want to stick this under the if, or maybe it should go outside it, and there's no way for the editor to automatically know and do the right thing. I often in emacs select the whole file and tell it to correct the identation... which is impossible in python?

Re:Thoughts of Python...

[BasilBrush]

Such a reformatting command will only reformat you YOUR preferences, not necessarily anyone elses. There is no universal standard for an editor to reformat to. Braces on lines by themselves itself, or hanging on the end of the line above? Indent the braces with the code, or just the code itself?

When you are maintaining code that you didn't write on a version control system, you almost certainly shouldn't be changing code just to reformat it. It causes diffs that are unrelated to meaningful changes in the source, and there is a danger of 2 or more coders flip-flopping between their personal preferences. Sure this can be counteracted with a house coding standard, but then you get the beligerant who won't change and the newcomers.

With python it's not an issue. You have to indent, and the only choices are a number of spaces or tabs. And if someone inserts new code that doesn match the existing format, all they'll get is a error message for their trouble.

I don't get your point about moving blocks and breaking the code. You need to be indented by the appropriate amount for the block level you are in. Conceptually, that is no different from needing the correct number of closing braces. And the significant indenting actually makes any mistakes easier to spot. If you have genuinly found this a significant problem, then I'd suggest that your functions are way too long.

good and bad

[rjnagle]

Funny, I have been reading both the online version and the print version over the weekend.

It is in many ways an excellent book, but geared towards more experienced programmers than I. The style is readable, but the program illustrating introspection (chapter 4 I believe) is really hard to get into. Mark could have chosen a better example.

I particularly liked the way that Pilgrim annotated the code. He started out a chapter with the raw code, broke them into blocks with annotations and then concluded the chapter with a review.

The approach of these diveinto books is to introduce unfamiliar concepts and then dissect them one by one. My only complaint is that sometimes he introduces a lot of things all at once. It would have been better (though less succinct) to use more examples with fewer concepts thrown together all at once. On the other hand, I can appreciate the succinctness of the example programs by presenting them without first dumbing them down. The good thing about diveintopython is that it helped me to read a program pretty easily --although that doesn't imply that I can apply this knowledge..Give me another week or two:) The key question is at what point do I feel like coding on my own? I tried the examples in chapters 1 and 2, and then didn't feel like I could start coding until I finished the first 8 chapters. (and am slowly getting the hang of it).

Interestingly, when I started out, I found that I was referring to Oreilly's Python in a Nutshell more and more. Didn't look that user friendly at first, now seemingly more useful.

My sense is that programming is a matter of incremental mastery. (First read Fun with Dick and Jane, then read Wizard of Oz, then Melville, then Shakespearean sonnets). This book starts out by throwing out the Shakespearean sonnets at us and then explaining piece by piece until we have a sense of the whole.

Guido von Rossum's tutorial is more of a stepping stone approach, though the example code is more academic than practical.

One advantage of the online book: great hyperlinked references to Rossum's tutorial and other sources.

Despite my griping, this was still a good instructive read (though challenging). And way to go Mark for putting this online for free!

We need a Dive into Zope book

[ikhalil]

I think someone should write us a Dive into zope book with the same quality as Dive into python!

The thinner, the better

[mwood]

Fat language books are just, well, fat. I learned 98% of FORTRAN IV from a book about .75" thick, and my ALGOL 68 book is even thinner. It takes very little space to thoroughly introduce the programmer to Modula or Icon. Even COBOL books don't have to be wordy even though most COBOL code is.

When I see a slender volume sitting among the telephone-directory-sized tomes, I usually pick it up on the assumption that it should be good if it's so lean. I am not often disappointed.

(I just realized that LISP books *all* tend to be rather slender. McCarthy, Siklossy, and Steele all managed to say quite a lot in very little space. Hmmm.)

Re:The thinner, the better

[njdj]

The thinnest language manual I've ever used was the BCPL manual, which described the full language and its library (with examples) in an A4-size manual less than 2mm thick. This was in the mid-1970s. Developed by Martin Richards at Cambridge (not sure when - 1970??), the language became popular at CERN and was used at the Lawrence Berkeley Laboratory and elsewhere, and influenced the design of C.

Re:python's list processing rules

[nkh]

Actually, I have a problem with lists comprehensions:

With Python: [ x ** 2 for x in xrange(100000) if x % 2 == 0 ] (8 seconds)
With Ruby: (1..100_000).select { |x| x % 2 == 0 }.map { |x| x ** 2 } (2 seconds)
but Ruby is supposed to be 10 times slower (not compiled, bigger...) What's happening? (it's not a troll, it's a real question)

I had no idea

[Cereal Box]

Mark Pilgrim works down the hall from me. I had no idea he wrote this particular book.

Small world.

Re:Downloaded and loved

[cryptochrome]

I've been programming pretty much exclusively in python lately - but as my programs have become more advanced the downsides are becoming more obvious. I ended up writing a python extension in C (painful when you've been programming in python). Specifically, you can't compile python - and interpreted it's just too slow for anything computationally expensive. Also you have to load the interpreter, (or embed w/extra modules) it's slow and uses more memory than it should.

PyObjC is a start, but the little differences in how things are implemented between Python and Objective C makes using it a bit difficult to learn. Plus it's mac-only. Pyrex looks interesting but I've yet to try it. PyPy seems to have been in development forever.

For starters, I think the distutils module needs an option to produce a package/binary that is runnable on any similar machine whether python is installed or not.

Python is amenable to a variety of programming styles, is very readable, has well developed libraries, and is quick to write. But I've found myself wanting more than it can deliver, in terms of raw speed and number-crunching power, and even occasionally the need for typing and assignment by reference. I hope they find some way to deliver it someday, or make a language that retains the ease and efficiency of python but is also compilable.

Re:My 2 cents

[Paulrothrock]

I don't know... I don't want a language that sees a difference between a space and a tab. If nothing's there, then it should mean nothing.

But, then again, I'm lazy, impatient, and full of hubris.

Re:My 2 cents

[gipsy boy]

If you hate that about Python, try Ruby.
I went berserk for Ruby first, in much the same as people here for Python..I think my first script in it was an irc quiz bot. But for more advanced things than simple parsers, I like Python better. It's also faster and has a lot more support in the form of wrappers for other libraries. I pretty much gave up on Ruby now, although it's a pretty language.
I'm quite sure you can do the things at the end of chapter 17 in Ruby too though, they're very similar in that respect.

Re:My 2 cents

[cpeterso]

If whitespace has no meaning, then why does your code include whitespace?

Try it, I just did....

[gr8_phk]

I finally decided to try Python about a week ago. My goal was to scrape some information from a web page for easy/compact display. Pulling the raw HTML from a given URL is simple with the urllib. Python string handling makes parsing text fun and easy. The interactive mode actually allows you to define functions on the fly and try them without editing/saving/compiling files. And lastly, the thing I feared most... The "indentation matters" concept is fantastic.

Using Tkinter for a GUI is not as simple as I had hoped, but that's because the Python documentation doesn't cover much TK and I'm new to it - hence I need to learn that too.

Practical Common Lisp

[entrox]

If you like the more practical approach of books like this and always wanted to see what the fuss about Common Lisp is all about, then Practical Common Lisp is for you. The book isn't finished yet, but some chapters are already online for review.
Learn CL while writing a flexible MP3 database, a spam filter or a generic parser generator for binary files. How about a streaming MP3 server or a unit test framework? It's all in there without the boring stuff, which usually accompanies books like these.

mod_python/PSP

[noselasd]

You guys discovered mod_python ?
Which now comes with PSP. That is, server side web scripting using
Python as the language. Similar in spirit to PHP, just using Python.
Amazingly much more fun than PHP.

Re:python's list processing rules

[Anonymous Coward]

l = l[1:]

that's something to be excited about?

Ruby:

l = l[1..-1]
or
l.shift

Perl:

shift @l

Lisp (sorta, you usually don't need to save it in a variable, just use it):

(cdr l)

l = [ do_something(x) for x in l ]

It would be a lot cooler if it wasn't just bolted onto the language as new syntax. In Ruby this kind of thing is just methods on the Array class, you can write your own, and you can do more than just "do_something()" you can pass arbitrary code:

l.each { |x|
do_something(x)
do_something_else(x)
return if x.funky?
}

List comprehensions are a bizarre thing to me. They have very limited use (once they go longer than one line, they become unreadable) and they are just tossed into the language. And they make Python's distinction between expressions and arbitrary code that much more noticable.

And unlike HAskell's, which use punctuation, Pythons use alphabetic characters! which makes it all that much harder to read:

bar = [ni.foo() for fi in inp if fi > baz]

Oh well, if it works for you..... but list comprehensions are a violation of Python's design principles if you ask me, and were just thrown in to make less stuff to type.

Re:My 2 cents

[William Tanksley]

Try it. You'll like it.

And anyhow, every programmer knows the difference between a space and a tab. And that neither one is "nothing". Anyone who tells you otherwise should try looking at C code written by hardware engineers someday (NO indentation at all).

The beauty of Python is that merely doing the responsible thing -- indenting your program -- makes it work. Someone who wants to "just make it work" (like, for example, a hardware programmer modifying C code) will automatically write approachable code; they HAVE to. No burden is added, since Python _replaces_ tracking curly braces with tracking indentation. And indentation is FAR more noticeable and visible.

-Billy

Re:python's list processing rules

[Black Acid]

I would guess Perl is optimizing away the map in a void context, but this doesn't seem to be the case. I recall a while back some discussion about optimizing the .. operator to not always create a full-blown list unless necessary; these changes must have been implemented.

On my system (using 1,000,000), Python takes 10 seconds, Perl takes 3. Even using @a=map { $_ ** 2 } grep { $_ % 2 == 0 } (1..1_000_000), forcing Perl to compute the list, Perl finishes in a mere 3-4 seconds. I ran these informal benchmarks in the debugger to discount any possibility of inclusing times being factored in.

Second benchmark, from the command line:

$ time perl a.pl
3.113u 0.488s 0:07.15 50.2% 10+96966k 0+0io 0pf+0w
$ time python a.py
14.209u 0.309s 0:18.55 78.1% 792+12392k 0+0io 0pf+0w

Looks like Python could use some optimization.

Also, there is a caveat with Python list comprehensions. In Perl, this (admittedly contrived) example prints 42:
$x=42;
@a=map( my $x=1; $_ ** 2 } grep { $_ % 2 == 0 } (1..10);
print $x;

In Python, you don't have a $_ variable, so you have to make your own--usually x:
x = 42
a = [ x ** 2 for x in xrange(10) if x % 2 == 0 ]
print x
Prints 9, not 42 because of Python's static lexical scoping.

Re:My 2 cents

[arkanes]

The thing that sucks about Python and it's indentation-awareness is that it makes it very hard to keep code intact on web pages, in emails, etc. With C (or other) languages, the indentation is for human-readability only and is trivially recreated mechanically. With Python if a file gets borked up you have to fix it by hand and it can be a real pain.

The surprise factor of mixing tabs and spaces can be annoying, too.

I've come to like Python a lot and I do most of my coding in it now, but I still think the indetation thing was the wrong choice.

Making money from technical books - not happening

[otisg]

As a co-author of an upcoming technical book (Lucene in Action - not a plug, just providing context), let me just address this:

Reading them, one gets the feeling that its primary purpose is to allow the author to make some payments on a car or mortgage.

Unless we are talking about a book that really interests a LARGE portion of the geeks out there, the above statement is really missing the point. I don't know any technical book authors who do it for the money. I am certainly not writing for the money. Royalties are nice, but they are really small in the end, especially when you consider the time and effort that you put in writing technical books. In addition, think about the 'life expectancy' of a book that covers a technical topic - not much longer than firefly's.

Long story short, one doesn't write this type of stuff to make money, and Mark certainly didn't write Dive into Python for $$$ - I've had it bookmark in my Simpy account (URL in sig) for 6+ months now. I just wanted to get this straight, so there is no confusion. This may also be interesting to those considering writing a book on a technical topic.

Re:python's list processing rules

[Anonymous Coward]

The optimization is utterly trivial: since from a certain point onwards, x**2 will no longer fit into a 32-bit integer, python has to coerce some ints into longs. If you do this beforehand, the difference is rather large: compare the original:

a = [ x ** 2 for x in xrange(1000000) if x % 2 == 0 ]

to

a = [ long(x) ** 2 for x in xrange(1000000) if x % 2 == 0 ]

using time, I get:

[real: 0m21.790s; user: 0m20.290s; sys: 0m0.110s] for the first one, and [real: 0m3.637s; user: 0m3.310s; sys: 0m0.070s] for the second. For good measure, I get [real: 0m4.084s; user: 0m3.500s; sys: 0m0.400s] with perl: that is slightly _slower_ than the python version.

I agree that perl apparently does this automatically, and python doesn't. That doesn't mean you can't it to go fast, but manual intervention is needed at this point.

Maarten

Re:Downloaded and loved

[cryptochrome]

Try SWIG, or PyRex, or Boost Python
I started with SWIG, and eventually decided it was easier to just write my one function myself instead of trying to learn all the ins and outs of swig. I didn't discover pyrex 'til later, and haven't really looked into boost.

compiled to byte code and then executed in a VM
Then I'd prefer that it not require a VM.
If you think it's to slow because it's not native the same goes for Java and C#.
Correct.
to point out that saying "it's too slow" without qualification is an old, tired, and disproven argument
The inner loop of my program as written in python was too slow for my purposes, therefore I rewrote it in c. Possibly I could have sped things up using some of the tricks I used to get around the lack of dicts in c to speed up the python problem as well - maybe I'll try it sometime, but I'm pretty much done with that program.

For the record, I think that saying "It's fast enough with modern machines" is a patently untrue argument that I hear far too often with less efficiently executed/compiled languages (Haskell for instance); a program may not be performance-demanding, but it will still be using system resources that are frequently in short supply.

what SPECIFICALLY are you talking about
That if I want to put a python program on a different computer than my own I have to either a) ensure that python and the necessary modules are already installed and are of the correct versions or b) install python of the correct version and necessary modules (often not an option) or c) make a distribution that includes all necessary modules, up to and including the standard ones, via freeze or bundlebuilder or py2exe.

That last option is not bad - it allows you to make single executable binaries/apps. I was under the impression it worked somewhat differently from that based on prior versions.

By computationally expensive, I mean analyzing many genomes for repetitions, and recording their frequency by distance and length, over a hundred times each. Hence the need for the inner loop to be as fast as possible, as most genomes took a about a day to process even with my c routine - when it was written in python they would have taken over a week each.

typing
What I meant to say was compile-time rather than run-time type-checking, i.e. there's no way to declare what type an argument should be and have inconsistencies be caught before you run.

Re:python's list processing rules

[Anonymous Coward]

l = l[1:]

Granted. But

l = l.subList(1,l.length()-1);

...isn't horrible. And in Lisp:

(setf l (subseq l 1))

...is pretty good.

List comprehensions are another great feature:

l = [ do_something(x) for x in l ]

Where the hell did Pythoners (and others) start using the incomprehensible term "list comprehensions"? Isn't the correct term ("function mapping" -- from Lisp, Scheme, Prolog, Mathematica, etc.) still sufficient?

BTW, here's some simple code for doing mapping in Java. Yes, it can be more efficient and general. No, I don't care.

public interface Mappable { public Object map(Object o); }
public class FMap
{
public static List over(Collection c, Mappable m)
{
List l = new ArrayList(c.length());
Iterator i = c.iterator();
while(i.hasNext()) l.add(m.map(i.next()));
return c;
}
}

You use it like this:

l = FMap.over(l, new Mappable() { public Object map(Object x) { do_something(x); } );

Ugly? Yes. But not all that long. It's just syntactical sugar. And in Lisp it's quite purty.

(setf l (mapcar #'do-something l)) ; for Lisp lists
(setf l (map 'vector #'do-something l)) ; for vectors (like Python)

Point is: these arguments are just syntactical arguments, and they're helpful but not all that much. Indeed, without a whole lot of work, Lisp can be modified to have EXACTLY the same syntax for maps and slices as Python does! Not the other way around though. Heck, Python is a language which only recently got true CLOSURES, for goodness sakes, and only with an additional module! As the Lisp guys used to say, here's a dime kid, come back when you've got yerself a better programming language. :-)

Re:I beg to differ with AccordianGuy's assessment

[AccordionGuy]

Are you sure I classify your book among the "bookends"? I never made reference to any specific books.

Hey, if you got a book deal and got to write about one of your favourite programming languages, you've gone farther along the publishing trail than I have. More power to you! I'm merely saying what kind of books I like.

Re:Ok, I'll bite...

[gujo-odori]

Maybe its more of a troll than flamebait, but I'll bite too :-)

While that's not entirely true( supporters of Free and Open Source Software do become managers a lot more often than some people might think), there is something else they do quite a lot: they become entrepreneurs.

I'm a believer in Free software, and while I'm more likely to become a manager than an entrepreneur (I'm already on the ladder), I do hope to become an entrepreneur one day. Not necessarily in IT; I'd like run a nice little coffeehouse bookstore with great connectivity, a great selection of technical books, live acoustic blues and other "real" music, and espresso that'll make your hair stand up for a week :-)

My wife owns her own business, so I've gotten a good look at the ups and downs of being a small business owner, and I've got to say that it still looks like something I'd like to do.

In conclusion, I'll just state that the GP says "[they] do not become managers" like that's a bad thing :-) And of course, I'll bet that he's not a manager either and won't become one with such narrow thinking.