diff --git a/case-study-porting-chardet-to-python-3.html b/case-study-porting-chardet-to-python-3.html index ce6fb63..20ff49f 100644 --- a/case-study-porting-chardet-to-python-3.html +++ b/case-study-porting-chardet-to-python-3.html @@ -1,106 +1,105 @@ - + - + Case study: porting chardet to Python 3 - Dive into Python 3 - - - - - -

skip to main content -

-

You are here: Home ‣ Dive Into Python 3 ‣ +

skip to main content +

+

You are here: Home ‣ Dive Into Python 3 ‣

Case study: porting chardet to Python 3

-
-

❝ Words, words. They’re all we have to go on. ❞
— Rosencrantz and Guildenstern are Dead +

+

❝ Words, words. They’re all we have to go on. ❞
— Rosencrantz and Guildenstern are Dead

    -
  1. Introducing chardet +
  2. Introducing chardet
      -
    1. What is character encoding auto-detection? -
    2. Isn’t that impossible? -
    3. Who wrote this detection algorithm? -
    4. Yippie! Screw the standards, I’ll just auto-detect everything! -
    5. Why bother with auto-detection if it’s slow, inaccurate, and non-standard? +
    6. What is character encoding auto-detection? +
    7. Isn’t that impossible? +
    8. Who wrote this detection algorithm? +
    9. Yippie! Screw the standards, I’ll just auto-detect everything! +
    10. Why bother with auto-detection if it’s slow, inaccurate, and non-standard?
    -
  3. Diving in +
  4. Diving in
      -
    1. UTF-n with a BOM -
    2. Escaped encodings -
    3. Multi-byte encodings -
    4. Single-byte encodings -
    5. windows-1252 +
    6. UTF-n with a BOM +
    7. Escaped encodings +
    8. Multi-byte encodings +
    9. Single-byte encodings +
    10. windows-1252
    -
  5. Running 2to3 -
  6. Fixing what 2to3 can’t +
  7. Running 2to3 +
  8. Fixing what 2to3 can’t
      -
    1. False is invalid syntax -
    2. No module named constants -
    3. Name 'file' is not defined -
    4. Can’t use a string pattern on a bytes-like object -
    5. Can’t convert 'bytes' object to str implicitly +
    6. False is invalid syntax +
    7. No module named constants +
    8. Name 'file' is not defined +
    9. Can’t use a string pattern on a bytes-like object +
    10. Can’t convert 'bytes' object to str implicitly
-

Introducing chardet: a mini-FAQ

-

When you think of “text,” you probably think of “characters and symbols I see on my computer screen.” But computers don’t deal in characters and symbols; they deal in bits and bytes. Every piece of text you’ve ever seen on a computer screen is actually stored in a particular character encoding. There are many different character encodings, some optimized for particular languages like Russian or Chinese or English, and others that can be used for multiple languages. Very roughly speaking, the character encoding provides a mapping between the stuff you see on your screen and the stuff your computer actually stores in memory and on disk. -

In reality, it’s more complicated than that. Many characters are common to multiple encodings, but each encoding may use a different sequence of bytes to actually store those characters in memory or on disk. So you can think of the character encoding as a kind of decryption key for the text. Whenever someone gives you a sequence of bytes and claims it’s “text”, you need to know what character encoding they used so you can decode the bytes into characters and display them (or process them, or whatever). -

What is character encoding auto-detection?

-

It means taking a sequence of bytes in an unknown character encoding, and attempting to determine the encoding so you can read the text. It’s like cracking a code when you don’t have the decryption key. -

Isn’t that impossible?

-

In general, yes. However, some encodings are optimized for specific languages, and languages are not random. Some character sequences pop up all the time, while other sequences make no sense. A person fluent in English who opens a newspaper and finds “txzqJv 2!dasd0a QqdKjvz” will instantly recognize that that isn’t English (even though it is composed entirely of English letters). By studying lots of “typical” text, a computer algorithm can simulate this kind of fluency and make an educated guess about a text’s language. +

Introducing chardet: a mini-FAQ

+

When you think of “text,” you probably think of “characters and symbols I see on my computer screen.” But computers don’t deal in characters and symbols; they deal in bits and bytes. Every piece of text you’ve ever seen on a computer screen is actually stored in a particular character encoding. There are many different character encodings, some optimized for particular languages like Russian or Chinese or English, and others that can be used for multiple languages. Very roughly speaking, the character encoding provides a mapping between the stuff you see on your screen and the stuff your computer actually stores in memory and on disk. +

In reality, it’s more complicated than that. Many characters are common to multiple encodings, but each encoding may use a different sequence of bytes to actually store those characters in memory or on disk. So you can think of the character encoding as a kind of decryption key for the text. Whenever someone gives you a sequence of bytes and claims it’s “text”, you need to know what character encoding they used so you can decode the bytes into characters and display them (or process them, or whatever). +

What is character encoding auto-detection?

+

It means taking a sequence of bytes in an unknown character encoding, and attempting to determine the encoding so you can read the text. It’s like cracking a code when you don’t have the decryption key. +

Isn’t that impossible?

+

In general, yes. However, some encodings are optimized for specific languages, and languages are not random. Some character sequences pop up all the time, while other sequences make no sense. A person fluent in English who opens a newspaper and finds “txzqJv 2!dasd0a QqdKjvz” will instantly recognize that that isn’t English (even though it is composed entirely of English letters). By studying lots of “typical” text, a computer algorithm can simulate this kind of fluency and make an educated guess about a text’s language.

In other words, encoding detection is really language detection, combined with knowledge of which languages tend to use which character encodings. -

Who wrote this detection algorithm?

-

This library is a port of the auto-detection code in Mozilla. I have attempted to maintain as much of the original structure as possible (mostly for selfish reasons, to make it easier to maintain the port as the original code evolves). I have also retained the original authors’ comments, which are quite extensive and informative. -

You may also be interested in the research paper which led to the Mozilla implementation, A composite approach to language/encoding detection. -

Yippie! Screw the standards, I’ll just auto-detect everything!

-

Don’t do that. Virtually every format and protocol contains a method for specifying character encoding. +

Who wrote this detection algorithm?

+

This library is a port of the auto-detection code in Mozilla. I have attempted to maintain as much of the original structure as possible (mostly for selfish reasons, to make it easier to maintain the port as the original code evolves). I have also retained the original authors’ comments, which are quite extensive and informative. +

You may also be interested in the research paper which led to the Mozilla implementation, A composite approach to language/encoding detection. +

Yippie! Screw the standards, I’ll just auto-detect everything!

+

Don’t do that. Virtually every format and protocol contains a method for specifying character encoding.

-

If text comes with explicit character encoding information, you should use it. If the text has no explicit information, but the relevant standard defines a default encoding, you should use that. (This is harder than it sounds, because standards can overlap. If you fetch an XML document over HTTP, you need to support both standards and figure out which one wins if they give you conflicting information.) -

Despite the complexity, it’s worthwhile to follow standards and respect explicit character encoding information. It will almost certainly be faster and more accurate than trying to auto-detect the encoding. It will also make the world a better place, since your program will interoperate with other programs that follow the same standards. -

Why bother with auto-detection if it’s slow, inaccurate, and non-standard?

-

Sometimes you receive text with verifiably inaccurate encoding information. Or text without any encoding information, and the specified default encoding doesn’t work. There are also some poorly designed standards that have no way to specify encoding at all. -

If following the relevant standards gets you nowhere, and you decide that processing the text is more important than maintaining interoperability, then you can try to auto-detect the character encoding as a last resort. An example is my Universal Feed Parser, which calls this auto-detection library only after exhausting all other options. -

Diving in

+

If text comes with explicit character encoding information, you should use it. If the text has no explicit information, but the relevant standard defines a default encoding, you should use that. (This is harder than it sounds, because standards can overlap. If you fetch an XML document over HTTP, you need to support both standards and figure out which one wins if they give you conflicting information.) +

Despite the complexity, it’s worthwhile to follow standards and respect explicit character encoding information. It will almost certainly be faster and more accurate than trying to auto-detect the encoding. It will also make the world a better place, since your program will interoperate with other programs that follow the same standards. +

Why bother with auto-detection if it’s slow, inaccurate, and non-standard?

+

Sometimes you receive text with verifiably inaccurate encoding information. Or text without any encoding information, and the specified default encoding doesn’t work. There are also some poorly designed standards that have no way to specify encoding at all. +

If following the relevant standards gets you nowhere, and you decide that processing the text is more important than maintaining interoperability, then you can try to auto-detect the character encoding as a last resort. An example is my Universal Feed Parser, which calls this auto-detection library only after exhausting all other options. +

Diving in

This is a brief guide to navigating the code itself. -

The main entry point for the detection algorithm is universaldetector.py, which has one class, UniversalDetector. (You might think the main entry point is the detect function in chardet/__init__.py, but that’s really just a convenience function that creates a UniversalDetector object, calls it, and returns its result.) +

The main entry point for the detection algorithm is universaldetector.py, which has one class, UniversalDetector. (You might think the main entry point is the detect function in chardet/__init__.py, but that’s really just a convenience function that creates a UniversalDetector object, calls it, and returns its result.)

There are 5 categories of encodings that UniversalDetector handles:

    -
  1. UTF-n with a BOM. This includes UTF-8, both BE and LE variants of UTF-16, and all 4 byte-order variants of UTF-32. -
  2. Escaped encodings, which are entirely 7-bit ASCII compatible, where non-ASCII characters start with an escape sequence. Examples: ISO-2022-JP (Japanese) and HZ-GB-2312 (Chinese). -
  3. Multi-byte encodings, where each character is represented by a variable number of bytes. Examples: Big5 (Chinese), SHIFT_JIS (Japanese), EUC-KR (Korean), and UTF-8 without a BOM. -
  4. Single-byte encodings, where each character is represented by one byte. Examples: KOI8-R (Russian), windows-1255 (Hebrew), and TIS-620 (Thai). +
  5. UTF-n with a BOM. This includes UTF-8, both BE and LE variants of UTF-16, and all 4 byte-order variants of UTF-32. +
  6. Escaped encodings, which are entirely 7-bit ASCII compatible, where non-ASCII characters start with an escape sequence. Examples: ISO-2022-JP (Japanese) and HZ-GB-2312 (Chinese). +
  7. Multi-byte encodings, where each character is represented by a variable number of bytes. Examples: Big5 (Chinese), SHIFT_JIS (Japanese), EUC-KR (Korean), and UTF-8 without a BOM. +
  8. Single-byte encodings, where each character is represented by one byte. Examples: KOI8-R (Russian), windows-1255 (Hebrew), and TIS-620 (Thai).
  9. windows-1252, which is used primarily on Microsoft Windows by middle managers who wouldn’t know a character encoding from a hole in the ground.
-

UTF-n with a BOM

-

If the text starts with a BOM, we can reasonably assume that the text is encoded in UTF-8, UTF-16, or UTF-32. (The BOM will tell us exactly which one; that’s what it’s for.) This is handled inline in UniversalDetector, which returns the result immediately without any further processing. -

Escaped encodings

-

If the text contains a recognizable escape sequence that might indicate an escaped encoding, UniversalDetector creates an EscCharSetProber (defined in escprober.py) and feeds it the text. -

EscCharSetProber creates a series of state machines, based on models of HZ-GB-2312, ISO-2022-CN, ISO-2022-JP, and ISO-2022-KR (defined in escsm.py). EscCharSetProber feeds the text to each of these state machines, one byte at a time. If any state machine ends up uniquely identifying the encoding, EscCharSetProber immediately returns the positive result to UniversalDetector, which returns it to the caller. If any state machine hits an illegal sequence, it is dropped and processing continues with the other state machines. -

Multi-byte encodings

-

Assuming no BOM, UniversalDetector checks whether the text contains any high-bit characters. If so, it creates a series of “probers” for detecting multi-byte encodings, single-byte encodings, and as a last resort, windows-1252. -

The multi-byte encoding prober, MBCSGroupProber (defined in mbcsgroupprober.py), is really just a shell that manages a group of other probers, one for each multi-byte encoding: Big5, GB2312, EUC-TW, EUC-KR, EUC-JP, SHIFT_JIS, and UTF-8. MBCSGroupProber feeds the text to each of these encoding-specific probers and checks the results. If a prober reports that it has found an illegal byte sequence, it is dropped from further processing (so that, for instance, any subsequent calls to UniversalDetector.feed() will skip that prober). If a prober reports that it is reasonably confident that it has detected the encoding, MBCSGroupProber reports this positive result to UniversalDetector, which reports the result to the caller. -

Most of the multi-byte encoding probers are inherited from MultiByteCharSetProber (defined in mbcharsetprober.py), and simply hook up the appropriate state machine and distribution analyzer and let MultiByteCharSetProber do the rest of the work. MultiByteCharSetProber runs the text through the encoding-specific state machine, one byte at a time, to look for byte sequences that would indicate a conclusive positive or negative result. At the same time, MultiByteCharSetProber feeds the text to an encoding-specific distribution analyzer. -

The distribution analyzers (each defined in chardistribution.py) use language-specific models of which characters are used most frequently. Once MultiByteCharSetProber has fed enough text to the distribution analyzer, it calculates a confidence rating based on the number of frequently-used characters, the total number of characters, and a language-specific distribution ratio. If the confidence is high enough, MultiByteCharSetProber returns the result to MBCSGroupProber, which returns it to UniversalDetector, which returns it to the caller. -

The case of Japanese is more difficult. Single-character distribution analysis is not always sufficient to distinguish between EUC-JP and SHIFT_JIS, so the SJISProber (defined in sjisprober.py) also uses 2-character distribution analysis. SJISContextAnalysis and EUCJPContextAnalysis (both defined in jpcntx.py and both inheriting from a common JapaneseContextAnalysis class) check the frequency of Hiragana syllabary characters within the text. Once enough text has been processed, they return a confidence level to SJISProber, which checks both analyzers and returns the higher confidence level to MBCSGroupProber. -

Single-byte encodings

-

The single-byte encoding prober, SBCSGroupProber (defined in sbcsgroupprober.py), is also just a shell that manages a group of other probers, one for each combination of single-byte encoding and language: windows-1251, KOI8-R, ISO-8859-5, MacCyrillic, IBM855, and IBM866 (Russian); ISO-8859-7 and windows-1253 (Greek); ISO-8859-5 and windows-1251 (Bulgarian); ISO-8859-2 and windows-1250 (Hungarian); TIS-620 (Thai); windows-1255 and ISO-8859-8 (Hebrew). -

SBCSGroupProber feeds the text to each of these encoding+language-specific probers and checks the results. These probers are all implemented as a single class, SingleByteCharSetProber (defined in sbcharsetprober.py), which takes a language model as an argument. The language model defines how frequently different 2-character sequences appear in typical text. SingleByteCharSetProber processes the text and tallies the most frequently used 2-character sequences. Once enough text has been processed, it calculates a confidence level based on the number of frequently-used sequences, the total number of characters, and a language-specific distribution ratio. -

Hebrew is handled as a special case. If the text appears to be Hebrew based on 2-character distribution analysis, HebrewProber (defined in hebrewprober.py) tries to distinguish between Visual Hebrew (where the source text actually stored "backwards" line-by-line, and then displayed verbatim so it can be read from right to left) and Logical Hebrew (where the source text is stored in reading order and then rendered right-to-left by the client). Because certain characters are encoded differently based on whether they appear in the middle of or at the end of a word, we can make a reasonable guess about direction of the source text, and return the appropriate encoding (windows-1255 for Logical Hebrew, or ISO-8859-8 for Visual Hebrew). -

windows-1252

-

If UniversalDetector detects a high-bit character in the text, but none of the other multi-byte or single-byte encoding probers return a confident result, it creates a Latin1Prober (defined in latin1prober.py) to try to detect English text in a windows-1252 encoding. This detection is inherently unreliable, because English letters are encoded in the same way in many different encodings. The only way to distinguish windows-1252 is through commonly used symbols like smart quotes, curly apostrophes, copyright symbols, and the like. Latin1Prober automatically reduces its confidence rating to allow more accurate probers to win if at all possible. -

Running 2to3

-

We’re going to migrate the chardet module from Python 2 to Python 3. Python 3 comes with a utility script called 2to3, which takes your actual Python 2 source code as input and auto-converts as much as it can to Python 3. In some cases this is easy -- a function was renamed or moved to a different modules -- but in other cases it can get pretty complex. To get a sense of all that it can do, refer to the appendix, Porting code to Python 3 with 2to3. In this chapter, we’ll start by running 2to3 on the chardet package, but as you’ll see, there will still be a lot of work to do after the automated tools have performed their magic. -

The main chardet package is split across several different files, all in the same directory. The 2to3 script makes it easy to convert multiple files at once: just pass a directory as a command line argument, and 2to3 will convert each of the files in turn. -

skip over this -

C:\home\chardet> python c:\Python30\Tools\Scripts\2to3.py -w chardet\
+
UTF-n with a BOM

+
If the text starts with a BOM, we can reasonably assume that the text is encoded in UTF-8, UTF-16, or UTF-32. (The BOM will tell us exactly which one; that’s what it’s for.)  This is handled inline in UniversalDetector, which returns the result immediately without any further processing.
+
Escaped encodings

+
If the text contains a recognizable escape sequence that might indicate an escaped encoding, UniversalDetector creates an EscCharSetProber (defined in escprober.py) and feeds it the text.
+
EscCharSetProber creates a series of state machines, based on models of HZ-GB-2312, ISO-2022-CN, ISO-2022-JP, and ISO-2022-KR (defined in escsm.py). EscCharSetProber feeds the text to each of these state machines, one byte at a time. If any state machine ends up uniquely identifying the encoding, EscCharSetProber immediately returns the positive result to UniversalDetector, which returns it to the caller. If any state machine hits an illegal sequence, it is dropped and processing continues with the other state machines.
+
Multi-byte encodings

+
Assuming no BOM, UniversalDetector checks whether the text contains any high-bit characters. If so, it creates a series of “probers” for detecting multi-byte encodings, single-byte encodings, and as a last resort, windows-1252.
+
The multi-byte encoding prober, MBCSGroupProber (defined in mbcsgroupprober.py), is really just a shell that manages a group of other probers, one for each multi-byte encoding: Big5, GB2312, EUC-TW, EUC-KR, EUC-JP, SHIFT_JIS, and UTF-8. MBCSGroupProber feeds the text to each of these encoding-specific probers and checks the results. If a prober reports that it has found an illegal byte sequence, it is dropped from further processing (so that, for instance, any subsequent calls to UniversalDetector.feed() will skip that prober). If a prober reports that it is reasonably confident that it has detected the encoding, MBCSGroupProber reports this positive result to UniversalDetector, which reports the result to the caller.
+
Most of the multi-byte encoding probers are inherited from MultiByteCharSetProber (defined in mbcharsetprober.py), and simply hook up the appropriate state machine and distribution analyzer and let MultiByteCharSetProber do the rest of the work. MultiByteCharSetProber runs the text through the encoding-specific state machine, one byte at a time, to look for byte sequences that would indicate a conclusive positive or negative result. At the same time, MultiByteCharSetProber feeds the text to an encoding-specific distribution analyzer.
+
The distribution analyzers (each defined in chardistribution.py) use language-specific models of which characters are used most frequently. Once MultiByteCharSetProber has fed enough text to the distribution analyzer, it calculates a confidence rating based on the number of frequently-used characters, the total number of characters, and a language-specific distribution ratio. If the confidence is high enough, MultiByteCharSetProber returns the result to MBCSGroupProber, which returns it to UniversalDetector, which returns it to the caller.
+
The case of Japanese is more difficult. Single-character distribution analysis is not always sufficient to distinguish between EUC-JP and SHIFT_JIS, so the SJISProber (defined in sjisprober.py) also uses 2-character distribution analysis. SJISContextAnalysis and EUCJPContextAnalysis (both defined in jpcntx.py and both inheriting from a common JapaneseContextAnalysis class) check the frequency of Hiragana syllabary characters within the text. Once enough text has been processed, they return a confidence level to SJISProber, which checks both analyzers and returns the higher confidence level to MBCSGroupProber.
+
Single-byte encodings

+
The single-byte encoding prober, SBCSGroupProber (defined in sbcsgroupprober.py), is also just a shell that manages a group of other probers, one for each combination of single-byte encoding and language: windows-1251, KOI8-R, ISO-8859-5, MacCyrillic, IBM855, and IBM866 (Russian); ISO-8859-7 and windows-1253 (Greek); ISO-8859-5 and windows-1251 (Bulgarian); ISO-8859-2 and windows-1250 (Hungarian); TIS-620 (Thai); windows-1255 and ISO-8859-8 (Hebrew).
+
SBCSGroupProber feeds the text to each of these encoding+language-specific probers and checks the results. These probers are all implemented as a single class, SingleByteCharSetProber (defined in sbcharsetprober.py), which takes a language model as an argument. The language model defines how frequently different 2-character sequences appear in typical text. SingleByteCharSetProber processes the text and tallies the most frequently used 2-character sequences. Once enough text has been processed, it calculates a confidence level based on the number of frequently-used sequences, the total number of characters, and a language-specific distribution ratio.
+
Hebrew is handled as a special case. If the text appears to be Hebrew based on 2-character distribution analysis, HebrewProber (defined in hebrewprober.py) tries to distinguish between Visual Hebrew (where the source text actually stored "backwards" line-by-line, and then displayed verbatim so it can be read from right to left) and Logical Hebrew (where the source text is stored in reading order and then rendered right-to-left by the client). Because certain characters are encoded differently based on whether they appear in the middle of or at the end of a word, we can make a reasonable guess about direction of the source text, and return the appropriate encoding (windows-1255 for Logical Hebrew, or ISO-8859-8 for Visual Hebrew).
+
windows-1252

+
If UniversalDetector detects a high-bit character in the text, but none of the other multi-byte or single-byte encoding probers return a confident result, it creates a Latin1Prober (defined in latin1prober.py) to try to detect English text in a windows-1252 encoding. This detection is inherently unreliable, because English letters are encoded in the same way in many different encodings. The only way to distinguish windows-1252 is through commonly used symbols like smart quotes, curly apostrophes, copyright symbols, and the like. Latin1Prober automatically reduces its confidence rating to allow more accurate probers to win if at all possible.
+
Running 2to3

+
We’re going to migrate the chardet module from Python 2 to Python 3. Python 3 comes with a utility script called 2to3, which takes your actual Python 2 source code as input and auto-converts as much as it can to Python 3. In some cases this is easy -- a function was renamed or moved to a different modules -- but in other cases it can get pretty complex. To get a sense of all that it can do, refer to the appendix, Porting code to Python 3 with 2to3. In this chapter, we’ll start by running 2to3 on the chardet package, but as you’ll see, there will still be a lot of work to do after the automated tools have performed their magic.
+
The main chardet package is split across several different files, all in the same directory. The 2to3 script makes it easy to convert multiple files at once: just pass a directory as a command line argument, and 2to3 will convert each of the files in turn.
+
skip over this
+
C:\home\chardet> python c:\Python30\Tools\Scripts\2to3.py -w chardet\
 RefactoringTool: Skipping implicit fixer: buffer
 RefactoringTool: Skipping implicit fixer: idioms
 RefactoringTool: Skipping implicit fixer: set_literal
@@ -566,9 +565,9 @@ RefactoringTool: chardet\sbcsgroupprober.py
 RefactoringTool: chardet\sjisprober.py
 RefactoringTool: chardet\universaldetector.py
 RefactoringTool: chardet\utf8prober.py

-
Now run the 2to3 script on the testing harness, test.py.
-
skip over this
-
C:\home\chardet> python c:\Python30\Tools\Scripts\2to3.py -w test.py
+
Now run the 2to3 script on the testing harness, test.py.
+
skip over this
+
C:\home\chardet> python c:\Python30\Tools\Scripts\2to3.py -w test.py
 RefactoringTool: Skipping implicit fixer: buffer
 RefactoringTool: Skipping implicit fixer: idioms
 RefactoringTool: Skipping implicit fixer: set_literal
@@ -598,21 +597,21 @@ RefactoringTool: Skipping implicit fixer: ws_comma
 +print(count, 'tests')
 RefactoringTool: Files that were modified:
 RefactoringTool: test.py

-
Well, that wasn’t so hard.  Just a few imports and print statements to convert.  Time to run the new version.  Do you think it’ll work?
-
Fixing what 2to3 can’t

-
False is invalid syntax

-
Now for the real test: running the test harness against the test suite.  Since the test suite is designed to cover all the possible code paths, it’s a good way to test our ported code to make sure there aren’t any bugs lurking anywhere.
-
skip over this
-
C:\home\chardet> python test.py tests\*\*
-Traceback (most recent call last):
+
Well, that wasn’t so hard. Just a few imports and print statements to convert. Time to run the new version. Do you think it’ll work?
+
Fixing what 2to3 can’t

+
False is invalid syntax

+
Now for the real test: running the test harness against the test suite. Since the test suite is designed to cover all the possible code paths, it’s a good way to test our ported code to make sure there aren’t any bugs lurking anywhere.
+
skip over this
+
C:\home\chardet> python test.py tests\*\*
+Traceback (most recent call last):
   File "test.py", line 1, in <module>
     from chardet.universaldetector import UniversalDetector
   File "C:\home\chardet\chardet\universaldetector.py", line 51
     self.done = constants.False
                               ^
 SyntaxError: invalid syntax

-
Hmm, a small snag.  In Python 3, False is a reserved word, so you can’t use it as a variable name.  Let’s look at constants.py to see where it’s defined.  Here’s the original version from constants.py, before the 2to3 script changed it:
-
skip over this
+
Hmm, a small snag. In Python 3, False is a reserved word, so you can’t use it as a variable name. Let’s look at constants.py to see where it’s defined. Here’s the original version from constants.py, before the 2to3 script changed it:
+
skip over this
 
import __builtin__
 if not hasattr(__builtin__, 'False'):
     False = 0
@@ -620,84 +619,84 @@ if not hasattr(__builtin__, 'False'):
 else:
     False = __builtin__.False
     True = __builtin__.True

-
This piece of code is designed to allow this library to run under older versions of Python 2.  Prior to Python 2.3 [FIXME-LINK], Python had no built-in Boolean type.  This code detects the absence of the built-in constants True and False, and defines them if necessary.
-
However, Python 3 will always have a Boolean type, so this entire code snippet is unnecessary.  The simplest solution is to replace all instances of constants.True and constants.False with True and False, respectively, then delete this dead code from constants.py.
-
So this line in universaldetector.py:
+
This piece of code is designed to allow this library to run under older versions of Python 2. Prior to Python 2.3 [FIXME-LINK], Python had no built-in Boolean type. This code detects the absence of the built-in constants True and False, and defines them if necessary.
+
However, Python 3 will always have a Boolean type, so this entire code snippet is unnecessary. The simplest solution is to replace all instances of constants.True and constants.False with True and False, respectively, then delete this dead code from constants.py.
+
So this line in universaldetector.py:
 
self.done = constants.False

 
Becomes
 
self.done = False

 
Ah, wasn’t that satisfying?  The code is shorter and more readable already.
-
No module named constants

-
Time to run test.py again and see how far it gets.
-
skip over this
-
C:\home\chardet> python test.py tests\*\*
-Traceback (most recent call last):
+
No module named constants

+
Time to run test.py again and see how far it gets.
+
skip over this
+
C:\home\chardet> python test.py tests\*\*
+Traceback (most recent call last):
   File "test.py", line 1, in <module>
     from chardet.universaldetector import UniversalDetector
   File "C:\home\chardet\chardet\universaldetector.py", line 29, in <module>
     import constants, sys
 ImportError: No module named constants

-
What’s that you say?  No module named constants?  Of course there’s a module named constants. ... Oh wait, no there isn’t.  Remember when the 2to3 script fixed up all those import statements?  This library has a lot of relative imports -- that is, modules that import other modules within the library.  In Python 3, all import statements are absolute by default [FIXME-LINK PEP 0328].  To do relative imports, you need to do something like this instead:
+
What’s that you say?  No module named constants?  Of course there’s a module named constants. ... Oh wait, no there isn’t. Remember when the 2to3 script fixed up all those import statements?  This library has a lot of relative imports -- that is, modules that import other modules within the library. In Python 3, all import statements are absolute by default [FIXME-LINK PEP 0328]. To do relative imports, you need to do something like this instead:
 
from . import constants

-
But wait.  Wasn’t the 2to3 script supposed to take care of these for you?  Well, it did, but this particular import statement combines two different types of imports into one line: a relative import of the constants module within the library, and an absolute import of the sys module that is pre-installed in the Python standard library.  In Python 2, you could combine these into one import statement.  In Python 3, you can’t, and the 2to3 script is not smart enough to split the import statement into two.
-
The solution is to split the import statement manually.  So this two-in-one import:
+
But wait. Wasn’t the 2to3 script supposed to take care of these for you?  Well, it did, but this particular import statement combines two different types of imports into one line: a relative import of the constants module within the library, and an absolute import of the sys module that is pre-installed in the Python standard library. In Python 2, you could combine these into one import statement. In Python 3, you can’t, and the 2to3 script is not smart enough to split the import statement into two.
+
The solution is to split the import statement manually. So this two-in-one import:
 
import constants, sys

 
Needs to become two separate imports:
 
from . import constants
 import sys

-
There are variations of this problem scattered throughout the chardet library.  In some places it’s "import constants, sys"; in other places, it’s "import constants, re".  The fix is the same: manually split the import statement into two lines, one for the relative import, the other for the absolute import.
+
There are variations of this problem scattered throughout the chardet library. In some places it’s "import constants, sys"; in other places, it’s "import constants, re". The fix is the same: manually split the import statement into two lines, one for the relative import, the other for the absolute import.
 
Onward!
-
Name 'file' is not defined

+
Name 'file' is not defined

 
FIXME intro
-
skip over this
-
C:\home\chardet> python test.py tests\*\*
+
skip over this
+
C:\home\chardet> python test.py tests\*\*
 tests\ascii\howto.diveintomark.org.xml
-Traceback (most recent call last):
+Traceback (most recent call last):
   File "test.py", line 9, in <module>
     for line in file(f, 'rb'):
 NameError: name 'file' is not defined

-
This one surprised me, because I’ve been using this idiom as long as I can remember.  In Python 2, the global file() function was an alias for open(), which was the standard way of opening files for reading.  In Python 3, the entire system for reading and writing files has been refactored into the io module. [FIXME-LINK PEP 3116]  I’ll cover the new I/O module in more detail in Chapter FIXME, but for now, the important bit is that the global file() function no longer exists.  However, the open() function does still exist.  (Technically, it’s an alias for io.open(), but never mind that right now.)
+
This one surprised me, because I’ve been using this idiom as long as I can remember. In Python 2, the global file() function was an alias for open(), which was the standard way of opening files for reading. In Python 3, the entire system for reading and writing files has been refactored into the io module. [FIXME-LINK PEP 3116]  I’ll cover the new I/O module in more detail in Chapter FIXME, but for now, the important bit is that the global file() function no longer exists. However, the open() function does still exist. (Technically, it’s an alias for io.open(), but never mind that right now.)
 
Thus, the simplest solution to the problem of the missing file() is to call open() instead:
 
for line in open(f, 'rb'):

 
And that’s all I have to say about that.
-
Can’t use a string pattern on a bytes-like object

+
Can’t use a string pattern on a bytes-like object

 
FIXME intro
-
skip over this
-
C:\home\chardet> python test.py tests\*\*
+
skip over this
+
C:\home\chardet> python test.py tests\*\*
 tests\ascii\howto.diveintomark.org.xml
-Traceback (most recent call last):
+Traceback (most recent call last):
   File "test.py", line 10, in <module>
     u.feed(line)
   File "C:\home\chardet\chardet\universaldetector.py", line 98, in feed
     if self._highBitDetector.search(aBuf):
 TypeError: can't use a string pattern on a bytes-like object

-
Now things are starting to get interesting.  And by “interesting,” I mean “confusing as all hell.”
-
First, let’s see what self._highBitDetector is.  It’s defined in the __init__ method of the UniversalDetector class:
-
skip over this
+
Now things are starting to get interesting. And by “interesting,” I mean “confusing as all hell.”
+
First, let’s see what self._highBitDetector is. It’s defined in the __init__ method of the UniversalDetector class:
+
skip over this
 
class UniversalDetector:
     def __init__(self):
         self._highBitDetector = re.compile(r'[\x80-\xFF]')

-
This pre-compiles a regular expression designed to find non-ASCII characters in the range 128-255 (0x80-0xFF).  Wait, that’s not quite right; I need to be more precise with my terminology.  This pattern is designed to find non-ASCII bytes in the range 128-255.
+
This pre-compiles a regular expression designed to find non-ASCII characters in the range 128-255 (0x80-0xFF). Wait, that’s not quite right; I need to be more precise with my terminology. This pattern is designed to find non-ASCII bytes in the range 128-255.
 
And therein lies the problem.
-
In Python 2, a string was an array of bytes whose character encoding was tracked separately.  If you wanted Python 2 to keep track of the character encoding, you had to use a Unicode string (u'') instead.  But in Python 3, a string is always what Python 2 called a Unicode string -- that is, an array of Unicode characters (of possibly varying byte lengths).  Since this regular expression is defined by a string pattern, it can only be used to search a string -- again, an array of characters.  But what we’re searching is not a string, it’s a byte array.  Looking at the traceback, this error occurred in universaldetector.py:
-
skip over this
+
In Python 2, a string was an array of bytes whose character encoding was tracked separately. If you wanted Python 2 to keep track of the character encoding, you had to use a Unicode string (u'') instead. But in Python 3, a string is always what Python 2 called a Unicode string -- that is, an array of Unicode characters (of possibly varying byte lengths). Since this regular expression is defined by a string pattern, it can only be used to search a string -- again, an array of characters. But what we’re searching is not a string, it’s a byte array. Looking at the traceback, this error occurred in universaldetector.py:
+
skip over this
 
def feed(self, aBuf):
     .
     .
     .
     if self._mInputState == ePureAscii:
         if self._highBitDetector.search(aBuf):

-
And what is aBuf?  Let’s backtrack further to a place that calls UniversalDetector.feed().  One place that calls it is the test harness, test.py.
-
skip over this
+
And what is aBuf?  Let’s backtrack further to a place that calls UniversalDetector.feed(). One place that calls it is the test harness, test.py.
+
skip over this
 
u = UniversalDetector()
 .
 .
 .
 for line in open(f, 'rb'):
     u.feed(line)

-
And here we find our answer: in the UniversalDetector.feed() method, aBuf is a line read from a file on disk.  Look carefully at the parameters used to open the file: 'rb'.  'r' is for “read”; OK, big deal, we’re reading the file.  Ah, but 'b' is for “binary.”  Without the 'b' flag, this for loop would read the file, line by line, and convert each line into a string -- an array of Unicode characters -- according to the system default character encoding.  (You could override the system encoding with another parameter to open(), but never mind that for now.)  But with the 'b' flag, this for loop reads the file, line by line, and stores each line exactly as it appears in the file, as an array of bytes.  That byte array gets passed to UniversalDetector.feed(), and eventually gets passed to the pre-compiled regular expression, self._highBitDetector, to search for high-bit... characters.  But we don’t have characters; we have bytes.  Oops.
+
And here we find our answer: in the UniversalDetector.feed() method, aBuf is a line read from a file on disk. Look carefully at the parameters used to open the file: 'rb'. 'r' is for “read”; OK, big deal, we’re reading the file. Ah, but 'b' is for “binary.”  Without the 'b' flag, this for loop would read the file, line by line, and convert each line into a string -- an array of Unicode characters -- according to the system default character encoding. (You could override the system encoding with another parameter to open(), but never mind that for now.)  But with the 'b' flag, this for loop reads the file, line by line, and stores each line exactly as it appears in the file, as an array of bytes. That byte array gets passed to UniversalDetector.feed(), and eventually gets passed to the pre-compiled regular expression, self._highBitDetector, to search for high-bit... characters. But we don’t have characters; we have bytes. Oops.
 
What we need this regular expression to search is not an array of characters, but an array of bytes.
-
Once you realize that, the solution is not difficult.  Regular expressions defined with strings can search strings.  Regular expressions defined with byte arrays can search byte arrays.  To define a byte array pattern, we simply change the type of the argument we use to define the regular expression to a byte array.  So instead of this:
+
Once you realize that, the solution is not difficult. Regular expressions defined with strings can search strings. Regular expressions defined with byte arrays can search byte arrays. To define a byte array pattern, we simply change the type of the argument we use to define the regular expression to a byte array. So instead of this:
 
self._highBitDetector = re.compile(r'[\x80-\xFF]')

 
We now have this:
 
self._highBitDetector = re.compile(b'[\x80-\xFF]')

@@ -705,20 +704,18 @@ for line in open(f, 'rb'):
 
self._escDetector = re.compile(r'(\033|~{)')

 
Again, this is going to be used to search a byte array (the same aBuf variable, in fact), so the regular expression pattern needs to be defined as a byte array:
 
self._escDetector = re.compile(b'(\033|~{)')

-
Can't convert 'bytes' object to str implicitly

+
Can't convert 'bytes' object to str implicitly

 
Curiouser and curiouser...
-
skip over this
-
C:\home\chardet> python test.py tests\*\*
+
skip over this
+
C:\home\chardet> python test.py tests\*\*
 tests\ascii\howto.diveintomark.org.xml
-Traceback (most recent call last):
+Traceback (most recent call last):
   File "test.py", line 10, in <module>
     u.feed(line)
   File "C:\home\chardet\chardet\universaldetector.py", line 100, in feed
     elif (self._mInputState == ePureAscii) and self._escDetector.search(self._mLastChar + aBuf):
 TypeError: Can't convert 'bytes' object to str implicitly

-
...
-
© 2001-4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
-
-
-
-
+
...
+
© 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
+
+
diff --git a/dip2 b/dip2
index b7460d2..0f4549b 100644
--- a/dip2
+++ b/dip2
@@ -4,11 +4,10 @@
 Dive Into Python
 
 
-
 
Dive Into Python

 
20 May 2004
 
Copyright © 2000, 2001, 2002, 2003, 2004 Mark Pilgrim
-
This book lives at http://diveintopython3.org/.  If you're reading it somewhere else, you may not have the latest version.
+
This book lives at http://diveintopython3.org/. If you're reading it somewhere else, you may not have the latest version.
 

 
Table of Contents
 
    
@@ -290,21 +289,21 @@
 

 

 
Chapter 1. Installing Python

-
Welcome to Python.  Let's dive in.  In this chapter, you'll install the version of Python that's right for you.
+
Welcome to Python. Let's dive in. In this chapter, you'll install the version of Python that's right for you.
 
1.1. Which Python is right for you?

-
The first thing you need to do with Python is install it.  Or do you?
-
If you're using an account on a hosted server, your ISP may have already installed Python.  Most popular Linux distributions come with Python in the default installation.  Mac OS X 10.2 and later includes a command-line version of Python, although you'll probably want to install a version that includes a more Mac-like graphical interface.
+
The first thing you need to do with Python is install it. Or do you?
+
If you're using an account on a hosted server, your ISP may have already installed Python. Most popular Linux distributions come with Python in the default installation. Mac OS X 10.2 and later includes a command-line version of Python, although you'll probably want to install a version that includes a more Mac-like graphical interface.
 
Windows does not come with any version of Python, but don't despair!  There are several ways to point-and-click your way to Python on Windows.
-
As you can see already, Python runs on a great many operating systems.  The full list includes Windows, Mac OS, Mac OS X, and all varieties of free UNIX-compatible systems like Linux.  There are also versions that run on Sun Solaris, AS/400, Amiga, OS/2, BeOS, and a plethora
+
As you can see already, Python runs on a great many operating systems. The full list includes Windows, Mac OS, Mac OS X, and all varieties of free UNIX-compatible systems like Linux. There are also versions that run on Sun Solaris, AS/400, Amiga, OS/2, BeOS, and a plethora
 of other platforms you've probably never even heard of.
-
What's more, Python programs written on one platform can, with a little care, run on any supported platform.  For instance, I regularly develop Python programs on Windows and later deploy them on Linux.
+
What's more, Python programs written on one platform can, with a little care, run on any supported platform. For instance, I regularly develop Python programs on Windows and later deploy them on Linux.
 
So back to the question that started this section, “Which Python is right for you?”  The answer is whichever one runs on the computer you already have.
 
1.2. Python on Windows

 
On Windows, you have a couple choices for installing Python.
 
ActiveState makes a Windows installer for Python called ActivePython, which includes a complete version of Python, an IDE with a Python-aware code editor, plus some Windows extensions for Python that allow complete access to Windows-specific services, APIs, and the Windows Registry.
-
ActivePython is freely downloadable, although it is not open source.  It is the IDE I used to learn Python, and I recommend you try it unless you have a specific reason not to.  One such reason might be that ActiveState is generally
-several months behind in updating their ActivePython installer when new version of Python are released.  If you absolutely need the latest version of Python and ActivePython is still a version behind as you read this, you'll want to use the second option for installing Python on Windows.
-
The second option is the “official” Python installer, distributed by the people who develop Python itself.  It is freely downloadable and open source, and it is always current with the latest version of Python.
+
ActivePython is freely downloadable, although it is not open source. It is the IDE I used to learn Python, and I recommend you try it unless you have a specific reason not to. One such reason might be that ActiveState is generally
+several months behind in updating their ActivePython installer when new version of Python are released. If you absolutely need the latest version of Python and ActivePython is still a version behind as you read this, you'll want to use the second option for installing Python on Windows.
+
The second option is the “official” Python installer, distributed by the people who develop Python itself. It is freely downloadable and open source, and it is always current with the latest version of Python.
 

 
Procedure 1.1. Option 1: Installing ActivePython

 
Here is the procedure for installing ActivePython:
@@ -326,7 +325,7 @@ several months behind in updating their ActivePython installer when new version
          absolutely can't spare the 14MB.
 
 
  • 
-
    After the installation is complete, close the installer and choose Start->Programs->ActiveState ActivePython 2.2->PythonWin IDE.  You'll see something like the following:
+
    After the installation is complete, close the installer and choose Start->Programs->ActiveState ActivePython 2.2->PythonWin IDE. You'll see something like the following:
 
 
 
    @@ -341,7 +340,7 @@ see 'Help/About PythonWin' for further copyright information.
 
    Download the latest Python Windows installer by going to http://www.python.org/ftp/python/ and selecting the highest version number listed, then downloading the .exe installer.
 
 
  • 
-
    Double-click the installer, Python-2.xxx.yyy.exe.  The name will depend on the version of Python available when you read this.
+
    Double-click the installer, Python-2.xxx.yyy.exe. The name will depend on the version of Python available when you read this.
 
 
  • 
 
    Step through the installer program.
@@ -350,10 +349,10 @@ see 'Help/About PythonWin' for further copyright information.
 
    If disk space is tight, you can deselect the HTMLHelp file, the utility scripts (Tools/), and/or the test suite (Lib/test/).
 
 
  • 
-
    If you do not have administrative rights on your machine, you can select Advanced Options, then choose Non-Admin Install.  This just affects where Registry entries and Start menu shortcuts are created.
+
    If you do not have administrative rights on your machine, you can select Advanced Options, then choose Non-Admin Install. This just affects where Registry entries and Start menu shortcuts are created.
 
 
  • 
-
    After the installation is complete, close the installer and select Start->Programs->Python 2.3->IDLE (Python GUI).  You'll see something like the following:
+
    After the installation is complete, close the installer and select Start->Programs->Python 2.3->IDLE (Python GUI). You'll see something like the following:
 
 
 
    @@ -370,8 +369,8 @@ Type "copyright", "credits" or "license()" for more information.
 IDLE 1.0
 >>> 
 
    1.3. Python on Mac OS X
    
-
    On Mac OS X, you have two choices for installing Python: install it, or don't install it.  You probably want to install it.
-
    Mac OS X 10.2 and later comes with a command-line version of Python preinstalled.  If you are comfortable with the command line, you can use this version for the first third of the book.  However,
+
    On Mac OS X, you have two choices for installing Python: install it, or don't install it. You probably want to install it.
+
    Mac OS X 10.2 and later comes with a command-line version of Python preinstalled. If you are comfortable with the command line, you can use this version for the first third of the book. However,
 the preinstalled version does not come with an XML parser, so when you get to the XML chapter, you'll need to install the full version.
 
    Rather than using the preinstalled version, you'll probably want to install the latest version, which also comes with a graphical
 interactive shell.
@@ -430,15 +429,15 @@ Type "help", "copyright", "credits", or "license" for more information.
 
    Double-click PythonIDE to launch Python.
 
 
-
    The MacPython IDE should display a splash screen, then take you to the interactive shell.  If the interactive shell does not appear, select
-Window->Python Interactive (Cmd-0).  The opening window will look something like this:
+
    The MacPython IDE should display a splash screen, then take you to the interactive shell. If the interactive shell does not appear, select
+Window->Python Interactive (Cmd-0). The opening window will look something like this:
 
     Python 2.3 (#2, Jul 30 2003, 11:45:28)
 [GCC 3.1 20020420 (prerelease)]
 Type "copyright", "credits" or "license" for more information.
 MacPython IDE 1.0.1
 >>> 
-
    Note that once you install the latest version, the pre-installed version is still present.  If you are running scripts from
+
    • Note that once you install the latest version, the pre-installed version is still present. If you are running scripts from
 the command line, you need to be aware which version of Python you are using.
 
    Example 1.1. Two versions of Python
     [localhost:~] you% python
@@ -479,8 +478,8 @@ Type "help", "copyright", "credits", or "license" for more information.
 
    Double-click Python IDE to launch Python.
 
 
-
    The MacPython IDE should display a splash screen, and then take you to the interactive shell.  If the interactive shell does not appear, select
-Window->Python Interactive (Cmd-0).  You'll see a screen like this:
+
    The MacPython IDE should display a splash screen, and then take you to the interactive shell. If the interactive shell does not appear, select
+Window->Python Interactive (Cmd-0). You'll see a screen like this:
 
     Python 2.3 (#2, Jul 30 2003, 11:45:28)
 [GCC 3.1 20020420 (prerelease)]
@@ -488,9 +487,9 @@ Type "copyright", "credits" or "license" for more information.
 MacPython IDE 1.0.1
 >>> 
 
    1.5. Python on RedHat Linux
    
-
    Installing under UNIX-compatible operating systems such as Linux is easy if you're willing to install a binary package.  Pre-built
-binary packages are available for most popular Linux distributions.  Or you can always compile from source.
-
    Download the latest Python RPM by going to http://www.python.org/ftp/python/ and selecting the highest version number listed, then selecting the rpms/ directory within that.  Then download the RPM with the highest version number.  You can install it with the rpm command, as shown here:
+
    Installing under UNIX-compatible operating systems such as Linux is easy if you're willing to install a binary package. Pre-built
+binary packages are available for most popular Linux distributions. Or you can always compile from source.
+
    Download the latest Python RPM by going to http://www.python.org/ftp/python/ and selecting the highest version number listed, then selecting the rpms/ directory within that. Then download the RPM with the highest version number. You can install it with the rpm command, as shown here:
 
    Example 1.2. Installing on RedHat Linux 9
     localhost:~$ su -
 Password: [enter your root password]
@@ -520,19 +519,19 @@ Type "help", "copyright", "credits", or "license" for more information.
 
 1 
 
-Whoops!  Just typing python gives you the older version of Python -- the one that was installed by default.  That's not the one you want.
+Whoops!  Just typing python gives you the older version of Python -- the one that was installed by default. That's not the one you want.
 
 
 
 2 
 
-At the time of this writing, the newest version is called python2.3.  You'll probably want to change the path on the first line of the sample scripts to point to the newer version.
+At the time of this writing, the newest version is called python2.3. You'll probably want to change the path on the first line of the sample scripts to point to the newer version.
 
 
 
 3 
 
-This is the complete path of the newer version of Python that you just installed.  Use this on the #! line (the first line of each script) to ensure that scripts are running under the latest version of Python, and be sure to type python2.3 to get into the interactive shell.
+This is the complete path of the newer version of Python that you just installed. Use this on the #! line (the first line of each script) to ensure that scripts are running under the latest version of Python, and be sure to type python2.3 to get into the interactive shell.
 
 
 
@@ -571,7 +570,7 @@ logout
 Type "help", "copyright", "credits" or "license" for more information.
 >>> [press Ctrl+D to exit]
 
    1.7. Python Installation from Source
    
-
    If you prefer to build from source, you can download the Python source code from http://www.python.org/ftp/python/.  Select the highest version number listed, download the .tgz file), and then do the usual configure, make, make install dance.
+
    If you prefer to build from source, you can download the Python source code from http://www.python.org/ftp/python/. Select the highest version number listed, download the .tgz file), and then do the usual configure, make, make install dance.
 
    Example 1.4. Installing from source
     localhost:~$ su -
 Password: [enter your root password]
@@ -611,9 +610,9 @@ Type "help", "copyright", "credits" or "license" for more information.
 localhost:~$ 
 
    1.8. The Interactive Shell
    
 
    Now that you have Python installed, what's this interactive shell thing you're running?
-
    It's like this: Python leads a double life.  It's an interpreter for scripts that you can run from the command line or run like applications, by
-double-clicking the scripts.  But it's also an interactive shell that can evaluate arbitrary statements and expressions. 
-This is extremely useful for debugging, quick hacking, and testing.  I even know some people who use the Python interactive shell in lieu of a calculator!
+
    It's like this: Python leads a double life. It's an interpreter for scripts that you can run from the command line or run like applications, by
+double-clicking the scripts. But it's also an interactive shell that can evaluate arbitrary statements and expressions. 
+This is extremely useful for debugging, quick hacking, and testing. I even know some people who use the Python interactive shell in lieu of a calculator!
 
    Launch the Python interactive shell in whatever way works on your platform, and let's dive in with the steps shown here:
 
    Example 1.5. First Steps in the Interactive Shell
     >>> 1 + 1               1
@@ -648,7 +647,7 @@ hello world
 
 
    1.9. Summary
    
 
    You should now have a version of Python installed that works for you.
-
    Depending on your platform, you may have more than one version of Python intsalled.  If so, you need to be aware of your paths.  If simply typing python on the command line doesn't run the version of Python that you want to use, you may need to enter the full pathname of your preferred version.
+
    Depending on your platform, you may have more than one version of Python intsalled. If so, you need to be aware of your paths. If simply typing python on the command line doesn't run the version of Python that you want to use, you may need to enter the full pathname of your preferred version.
 
    Congratulations, and welcome to Python.
 
    
 
    Chapter 2. Your First Python Program
    
@@ -656,7 +655,7 @@ hello world
 Let's skip all that.
 
    2.1. Diving in
    
 
    Here is a complete, working Python program.
-
    It probably makes absolutely no sense to you.  Don't worry about that, because you're going to dissect it line by line.  But
+
    It probably makes absolutely no sense to you. Don't worry about that, because you're going to dissect it line by line. But
 read through it first and see what, if anything, you can make of it.
 
    Example 2.1. odbchelper.py
    
 
    If you have not already done so, you can download this and other examples used in this book.
    @@ -678,7 +677,7 @@ if __name__ == "__main__":
 
 
 In the ActivePython IDE on Windows, you can run the Python program you're editing by choosing
-File->Run... (Ctrl-R).  Output is displayed in the interactive window.
+File->Run... (Ctrl-R). Output is displayed in the interactive window.
 
 
 
@@ -687,7 +686,7 @@ File->Run... (Ctrl-R).  Output is displayed in the i
 
    
 
    
 In the Python IDE on Mac OS, you can run a Python program with
-Python->Run window... (Cmd-R), but there is an important option you must set first.  Open the .py file in the IDE, pop up the options menu by clicking the black triangle in the upper-right corner of the window, and make sure the Run as __main__ option is checked.  This is a per-file setting, but you'll only need to do it once per file.
+Python->Run window... (Cmd-R), but there is an important option you must set first. Open the .py file in the IDE, pop up the options menu by clicking the black triangle in the upper-right corner of the window, and make sure the Run as __main__ option is checked. This is a per-file setting, but you'll only need to do it once per file.
 
 
    
 
    
@@ -699,27 +698,27 @@ Python->Run window... (Cmd-R), but there is an impor
 
    
 
    
 
    The id="odbchelper.output" output of odbchelper.py will look like this:
    server=mpilgrim;uid=sa;database=master;pwd=secret
    2.2. Declaring Functions
    
-
    Python has functions like most other languages, but it does not have separate header files like C++ or interface/implementation sections like Pascal.  When you need a function, just declare it, like this:
+
    Python has functions like most other languages, but it does not have separate header files like C++ or interface/implementation sections like Pascal. When you need a function, just declare it, like this:
 
    -def buildConnectionString(params):
    Note that the keyword def starts the function declaration, followed by the function name, followed by the arguments in parentheses.  Multiple arguments
+def buildConnectionString(params):
    Note that the keyword def starts the function declaration, followed by the function name, followed by the arguments in parentheses. Multiple arguments
 (not shown here) are separated with commas.
-
    Also note that the function doesn't define a return datatype.  Python functions do not specify the datatype of their return value; they don't even specify whether or not they return a value.
+
    Also note that the function doesn't define a return datatype. Python functions do not specify the datatype of their return value; they don't even specify whether or not they return a value.
 In fact, every Python function returns a value; if the function ever executes a return statement, it will return that value, otherwise it will return None, the Python null value.
-
    
 
    
 Note
 
    
 
    In Visual Basic, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub.  There are no subroutines in Python.  Everything is a function, all functions return a value (even if it's None), and all functions start with def.
+In Visual Basic, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub. There are no subroutines in Python. Everything is a function, all functions return a value (even if it's None), and all functions start with def.
 
 
    
 
    
-
    The argument, params, doesn't specify a datatype.  In Python, variables are never explicitly typed.  Python figures out what type a variable is and keeps track of it internally.
+
    The argument, params, doesn't specify a datatype. In Python, variables are never explicitly typed. Python figures out what type a variable is and keeps track of it internally.
    
 
    
 Note
 
    
 
    
 In Java, C++, and other statically-typed languages, you must specify the datatype of the function return value and each function argument.
-       In Python, you never explicitly specify the datatype of anything.  Based on what value you assign, Python keeps track of the datatype internally.
+       In Python, you never explicitly specify the datatype of anything. Based on what value you assign, Python keeps track of the datatype internally.
 
 
    
 
    
@@ -728,17 +727,17 @@ In fact, every Python function returns a value; if the function ever executes a
 
    
 
    
 
    statically typed language
    
-
    A language in which types are fixed at compile time.  Most statically typed languages enforce this by requiring you to declare
-         all variables with their datatypes before using them.  Java and C are statically typed languages.
+
    A language in which types are fixed at compile time. Most statically typed languages enforce this by requiring you to declare
+         all variables with their datatypes before using them. Java and C are statically typed languages.
 
    
 
    dynamically typed language
    
-
    A language in which types are discovered at execution time; the opposite of statically typed.  VBScript and Python are dynamically typed, because they figure out what type a variable is when you first assign it a value.
+
    A language in which types are discovered at execution time; the opposite of statically typed. VBScript and Python are dynamically typed, because they figure out what type a variable is when you first assign it a value.
 
    
 
    strongly typed language
    
-
    A language in which types are always enforced.  Java and Python are strongly typed.  If you have an integer, you can't treat it like a string without explicitly converting it.
+
    A language in which types are always enforced. Java and Python are strongly typed. If you have an integer, you can't treat it like a string without explicitly converting it.
 
    
 
    weakly typed language
    
-
    A language in which types may be ignored; the opposite of strongly typed.  VBScript is weakly typed.  In VBScript, you can concatenate the string '12' and the integer 3 to get the string '123', then treat that as the integer 123, all without any explicit conversion.
+
    A language in which types may be ignored; the opposite of strongly typed. VBScript is weakly typed. In VBScript, you can concatenate the string '12' and the integer 3 to get the string '123', then treat that as the integer 123, all without any explicit conversion.
 
    
 
    
 
    So Python is both dynamically typed (because it doesn't use explicit datatype declarations) and strongly typed (because once a variable has a datatype, it actually matters).
@@ -748,8 +747,8 @@ In fact, every Python function returns a value; if the function ever executes a
 def buildConnectionString(params):
     """Build a connection string from a dictionary of parameters.
 
-    Returns string."""
    Triple quotes signify a multi-line string.  Everything between the start and end quotes is part of a single string, including
-   carriage returns and other quote characters.  You can use them anywhere, but you'll see them most often used when defining
+    Returns string."""
    Triple quotes signify a multi-line string. Everything between the start and end quotes is part of a single string, including
+   carriage returns and other quote characters. You can use them anywhere, but you'll see them most often used when defining
    a docstring.
 
    
@@ -760,13 +759,13 @@ def buildConnectionString(params):
 
    
 
    
 
    
 
    
-
    Everything between the triple quotes is the function's docstring, which documents what the function does.  A docstring, if it exists, must be the first thing defined in a function (that is, the first thing after the colon).  You don't technically
-need to give your function a docstring, but you always should.  I know you've heard this in every programming class you've ever taken, but Python gives you an added incentive: the docstring is available at runtime as an attribute of the function.
+
    Everything between the triple quotes is the function's docstring, which documents what the function does. A docstring, if it exists, must be the first thing defined in a function (that is, the first thing after the colon). You don't technically
+need to give your function a docstring, but you always should. I know you've heard this in every programming class you've ever taken, but Python gives you an added incentive: the docstring is available at runtime as an attribute of the function.
    
-
    
 
    
 Note
 
    
 
    Many Python IDEs use the docstring to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip.  This can be incredibly helpful, but it's only as good as the docstrings you write.
+Many Python IDEs use the docstring to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip. This can be incredibly helpful, but it's only as good as the docstrings you write.
 
 
    
 
    
@@ -777,29 +776,29 @@ need to give your function a docstring, but you always should.  I k
 
 
    2.4. Everything Is an Object
    
 
    2.6. Testing Modules
    
-
    Python modules are objects and have several useful attributes.  You can use this to easily test your modules as you write them.
+
    Python modules are objects and have several useful attributes. You can use this to easily test your modules as you write them.
    Here's an example that uses the if __name__ trick.
 
    -if __name__ == "__main__":
    Some quick observations before you get to the good stuff.  First, parentheses are not required around the if expression.  Second, the if statement ends with a colon, and is followed by indented code.
+if __name__ == "__main__":
    Some quick observations before you get to the good stuff. First, parentheses are not required around the if expression. Second, the if statement ends with a colon, and is followed by indented code.
    
-
    
 
    
 Note
 
    
 
    Like C, Python uses == for comparison and = for assignment.  Unlike C, Python does not support in-line assignment, so there's no chance of accidentally assigning the value you thought you were comparing.
+Like C, Python uses == for comparison and = for assignment. Unlike C, Python does not support in-line assignment, so there's no chance of accidentally assigning the value you thought you were comparing.
 
 
    
 
    
-
    So why is this particular if statement a trick?  Modules are objects, and all modules have a built-in attribute __name__.  A module's __name__ depends on how you're using the module.  If you import the module, then __name__ is the module's filename, without a directory path or file extension.  But you can also run the module directly as a standalone
+
    So why is this particular if statement a trick?  Modules are objects, and all modules have a built-in attribute __name__. A module's __name__ depends on how you're using the module. If you import the module, then __name__ is the module's filename, without a directory path or file extension. But you can also run the module directly as a standalone
 program, in which case __name__ will be a special default value, __main__.
 
    >>> import odbchelper
 >>> odbchelper.__name__
-'odbchelper'
    Knowing this, you can design a test suite for your module within the module itself by putting it in this if statement.  When you run the module directly, __name__ is __main__, so the test suite executes.  When you import the module, __name__ is something else, so the test suite is ignored.  This makes it easier to develop and debug new modules before integrating
+'odbchelper'
    • Knowing this, you can design a test suite for your module within the module itself by putting it in this if statement. When you run the module directly, __name__ is __main__, so the test suite executes. When you import the module, __name__ is something else, so the test suite is ignored. This makes it easier to develop and debug new modules before integrating
 them into a larger program.
-
@@ -813,485 +812,9 @@ them into a larger program.
    
 
    
 Tip
 
    
 
    On MacPython, there is an additional step to make the if __name__ trick work.  Pop up the module's options menu by clicking the black triangle in the upper-right corner of the window, and
+On MacPython, there is an additional step to make the if __name__ trick work. Pop up the module's options menu by clicking the black triangle in the upper-right corner of the window, and
       make sure Run as __main__ is checked.
 
 
    Chapter 3. Native Datatypes
    3.2. Introducing Lists
    
-
    Lists are Python's workhorse datatype.  If your only experience with lists is arrays in Visual Basic or (God forbid) the datastore in Powerbuilder, brace yourself for Python lists.
    
 
 
    
-
-
-
-
-
-
-
    Note
    A list in Python is like an array in Perl.  In Perl, variables that store arrays always start with the @ character; in Python, variables can be named anything, and Python keeps track of the datatype internally.
-
    
-
-
-
-
-
-
-
    Note
    A list in Python is much more than an array in Java (although it can be used as one if that's really all you want out of life).  A better analogy would be to the ArrayList class, which can hold arbitrary objects and can expand dynamically as new items are added.
-
    
-
    3.2.1. Defining Lists
    
-
    Example 3.6. Defining a List
    >>> li = ["a", "b", "mpilgrim", "z", "example"] 1
->>> li
-['a', 'b', 'mpilgrim', 'z', 'example']
->>> li[0]   2
-'a'
->>> li[4]   3
-'example'
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-First, you define a list of five elements.  Note that they retain their original order.  This is not an accident.  A list
-               is an ordered set of elements enclosed in square brackets.
-
    2 
-A list can be used like a zero-based array.  The first element of any non-empty list is always li[0].
-
    3 
-The last element of this five-element list is li[4], because lists are always zero-based.
-
    
-
    Example 3.7. Negative List Indices
    >>> li
-['a', 'b', 'mpilgrim', 'z', 'example']
->>> li[-1] 1
-'example'
->>> li[-3] 2
-'mpilgrim'
    
-
-
-
-
-
-
-
-
-
-
    1 
-A negative index accesses elements from the end of the list counting backwards.  The last element of any non-empty list is
-               always li[-1].
-
    2 
-If the negative index is confusing to you, think of it this way: li[-n] == li[len(li) - n].  So in this list, li[-3] == li[5 - 3] == li[2].
-
    
-
    Example 3.8. Slicing a List
    >>> li
-['a', 'b', 'mpilgrim', 'z', 'example']
->>> li[1:3]  1
-['b', 'mpilgrim']
->>> li[1:-1] 2
-['b', 'mpilgrim', 'z']
->>> li[0:3]  3
-['a', 'b', 'mpilgrim']
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-You can get a subset of a list, called a “slice”, by specifying two indices.  The return value is a new list containing all the elements of the list, in order, starting with
-               the first slice index (in this case li[1]), up to but not including the second slice index (in this case li[3]).
-
    2 
-Slicing works if one or both of the slice indices is negative.  If it helps, you can think of it this way: reading the list
-               from left to right, the first slice index specifies the first element you want, and the second slice index specifies the first
-               element you don't want.  The return value is everything in between.
-
    3 
-Lists are zero-based, so li[0:3] returns the first three elements of the list, starting at li[0], up to but not including li[3].
-
    
-
    Example 3.9. Slicing Shorthand
    >>> li
-['a', 'b', 'mpilgrim', 'z', 'example']
->>> li[:3] 1
-['a', 'b', 'mpilgrim']
->>> li[3:] 2 3
-['z', 'example']
->>> li[:]  4
-['a', 'b', 'mpilgrim', 'z', 'example']
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-If the left slice index is 0, you can leave it out, and 0 is implied.  So li[:3] is the same as li[0:3] from Example 3.8, “Slicing a List”.
-
    2 
-Similarly, if the right slice index is the length of the list, you can leave it out.  So li[3:] is the same as li[3:5], because this list has five elements.
-
    3 
-Note the symmetry here.  In this five-element list, li[:3] returns the first 3 elements, and li[3:] returns the last two elements.  In fact, li[:n] will always return the first n elements, and li[n:] will return the rest, regardless of the length of the list.
-
    4 
-If both slice indices are left out, all elements of the list are included.  But this is not the same as the original li list; it is a new list that happens to have all the same elements.  li[:] is shorthand for making a complete copy of a list.
-
    
-
    3.2.2. Adding Elements to Lists
    
-
    Example 3.10. Adding Elements to a List
    >>> li
-['a', 'b', 'mpilgrim', 'z', 'example']
->>> li.append("new")               1
->>> li
-['a', 'b', 'mpilgrim', 'z', 'example', 'new']
->>> li.insert(2, "new")            2
->>> li
-['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
->>> li.extend(["two", "elements"]) 3
->>> li
-['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-append adds a single element to the end of the list.
-
    2 
-insert inserts a single element into a list.  The numeric argument is the index of the first element that gets bumped out of position.
-                Note that list elements do not need to be unique; there are now two separate elements with the value 'new', li[2] and li[6].
-
    3 
-extend concatenates lists.  Note that you do not call extend with multiple arguments; you call it with one argument, a list.  In this case, that list has two elements.
-
    
-
    Example 3.11. The Difference between extend and append
    ->>> li = ['a', 'b', 'c']
->>> li.extend(['d', 'e', 'f']) 1
->>> li
-['a', 'b', 'c', 'd', 'e', 'f']
->>> len(li)  2
-6
->>> li[-1]
-'f'
->>> li = ['a', 'b', 'c']
->>> li.append(['d', 'e', 'f']) 3
->>> li
-['a', 'b', 'c', ['d', 'e', 'f']]
->>> len(li)  4
-4
->>> li[-1]
-['d', 'e', 'f']
-
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-Lists have two methods, extend and append, that look like they do the same thing, but are in fact completely different.  extend takes a single argument, which is always a list, and adds each of the elements of that list to the original list.
-
    2 
-Here you started with a list of three elements ('a', 'b', and 'c'), and you extended the list with a list of another three elements ('d', 'e', and 'f'), so you now have a list of six elements.
-
    3 
-On the other hand, append takes one argument, which can be any data type, and simply adds it to the end of the list.  Here, you're calling the append method with a single argument, which is a list of three elements.
-
    4 
-Now the original list, which started as a list of three elements, contains four elements.  Why four?  Because the last element
-               that you just appended is itself a list.  Lists can contain any type of data, including other lists.  That may be what you want, or maybe not.  Don't use append if you mean extend.
-
    
-
    3.2.3. Searching Lists
    
-
    Example 3.12. Searching a List
    >>> li
-['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
->>> li.index("example") 1
-5
->>> li.index("new")     2
-2
->>> li.index("c")       3
-Traceback (innermost last):
-  File "<interactive input>", line 1, in ?
-ValueError: list.index(x): x not in list
->>> "c" in li           4
-False
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-index finds the first occurrence of a value in the list and returns the index.
-
    2 
-index finds the first occurrence of a value in the list.  In this case, 'new' occurs twice in the list, in li[2] and li[6], but index will return only the first index, 2.
-
    3 
-If the value is not found in the list, Python raises an exception.  This is notably different from most languages, which will return some invalid index.  While this may
-               seem annoying, it is a good thing, because it means your program will crash at the source of the problem, rather than later
-               on when you try to use the invalid index.
-
    4 
-To test whether a value is in the list, use in, which returns True if the value is found or False if it is not.
-
    
-
    
-
-
-
-
-
-
-
    Note
    Before version 2.2.1, Python had no separate boolean datatype.  To compensate for this, Python accepted almost anything in a boolean context (like an if statement), according to the following rules:
-
    
-
      
-
    • 0 is false; all other numbers are true.
-
-
    • An empty string ("") is false, all other strings are true.
-
-
    • An empty list ([]) is false; all other lists are true.
-
-
    • An empty tuple (()) is false; all other tuples are true.
-
-
    • An empty dictionary ({}) is false; all other dictionaries are true.
-
-
    
-
    These rules still apply in Python 2.2.1 and beyond, but now you can also use an actual boolean, which has a value of True or False.  Note the capitalization; these values, like everything else in Python, are case-sensitive.
-
    
-
    3.2.4. Deleting List Elements
    
-
    Example 3.13. Removing Elements from a List
    >>> li
-['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
->>> li.remove("z")   1
->>> li
-['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
->>> li.remove("new") 2
->>> li
-['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
->>> li.remove("c")   3
-Traceback (innermost last):
-  File "<interactive input>", line 1, in ?
-ValueError: list.remove(x): x not in list
->>> li.pop()         4
-'elements'
->>> li
-['a', 'b', 'mpilgrim', 'example', 'new', 'two']
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-remove removes the first occurrence of a value from a list.
-
    2 
-remove removes only the first occurrence of a value.  In this case, 'new' appeared twice in the list, but li.remove("new") removed only the first occurrence.
-
    3 
-If the value is not found in the list, Python raises an exception.  This mirrors the behavior of the index method.
-
    4 
-pop is an interesting beast.  It does two things: it removes the last element of the list, and it returns the value that it removed.
-                Note that this is different from li[-1], which returns a value but does not change the list, and different from li.remove(value), which changes the list but does not return a value.
-
    
-
    3.2.5. Using List Operators
    
-
    Example 3.14. List Operators
    >>> li = ['a', 'b', 'mpilgrim']
->>> li = li + ['example', 'new'] 1
->>> li
-['a', 'b', 'mpilgrim', 'example', 'new']
->>> li += ['two']                2
->>> li
-['a', 'b', 'mpilgrim', 'example', 'new', 'two']
->>> li = [1, 2] * 3              3
->>> li
-[1, 2, 1, 2, 1, 2]
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-Lists can also be concatenated with the + operator.  list = list + otherlist has the same result as list.extend(otherlist).  But the + operator returns a new (concatenated) list as a value, whereas extend only alters an existing list.  This means that extend is faster, especially for large lists.
-
    2 
-Python supports the += operator.  li += ['two'] is equivalent to li.extend(['two']).  The += operator works for lists, strings, and integers, and it can be overloaded to work for user-defined classes as well.  (More
-               on classes in Chapter 5.)
-
    3 
-The * operator works on lists as a repeater.  li = [1, 2] * 3 is equivalent to li = [1, 2] + [1, 2] + [1, 2], which concatenates the three lists into one.
-
    
-
    
-
    Further Reading on Lists
    
-
-
    3.3. Introducing Tuples
    
-
    A tuple is an immutable list.  A tuple can not be changed in any way once it is created.
-
    Example 3.15. Defining a tuple
    >>> t = ("a", "b", "mpilgrim", "z", "example") 1
->>> t
-('a', 'b', 'mpilgrim', 'z', 'example')
->>> t[0]   2
-'a'
->>> t[-1]  3
-'example'
->>> t[1:3] 4
-('b', 'mpilgrim')
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-A tuple is defined in the same way as a list, except that the whole set of elements is enclosed in parentheses instead of
-            square brackets.
-
    2 
-The elements of a tuple have a defined order, just like a list.  Tuples indices are zero-based, just like a list, so the first
-            element of a non-empty tuple is always t[0].
-
    3 
-Negative indices count from the end of the tuple, just as with a list.
    4 
-Slicing works too, just like a list.  Note that when you slice a list, you get a new list; when you slice a tuple, you get
-            a new tuple.
-
    
-
    Example 3.16. Tuples Have No Methods
    >>> t
-('a', 'b', 'mpilgrim', 'z', 'example')
->>> t.append("new")    1
-Traceback (innermost last):
-  File "<interactive input>", line 1, in ?
-AttributeError: 'tuple' object has no attribute 'append'
->>> t.remove("z")      2
-Traceback (innermost last):
-  File "<interactive input>", line 1, in ?
-AttributeError: 'tuple' object has no attribute 'remove'
->>> t.index("example") 3
-Traceback (innermost last):
-  File "<interactive input>", line 1, in ?
-AttributeError: 'tuple' object has no attribute 'index'
->>> "z" in t           4
-True
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    1 
-You can't add elements to a tuple.  Tuples have no append or extend method.
-
    2 
-You can't remove elements from a tuple.  Tuples have no remove or pop method.
-
    3 
-You can't find elements in a tuple.  Tuples have no index method.
-
    4 
-You can, however, use in to see if an element exists in the tuple.
-
    
-
    So what are tuples good for?
-
    
-
      
-
    • Tuples are faster than lists.  If you're defining a constant set of values and all you're ever going to do with it is iterate
-      through it, use a tuple instead of a list.
-
-
    • It makes your code safer if you “write-protect” data that does not need to be changed.  Using a tuple instead of a list is like having an implied assert statement that shows this data is constant, and that special thought (and a specific function) is required to override that.
-
-
    • Remember that I said that dictionary keys can be integers, strings, and “a few other types”?  Tuples are one of those types.  Tuples can be used as keys in a dictionary, but lists can't be used this way.Actually, it's more complicated than that.  Dictionary keys must be immutable.  Tuples themselves are immutable, but if you
-      have a tuple of lists, that counts as mutable and isn't safe to use as a dictionary key.  Only tuples of strings, numbers,
-      or other dictionary-safe tuples can be used as dictionary keys.
-
-
    • Tuples are used in string formatting, as you'll see shortly.
-
    
-
    
-
-
-
-
-
-
-
    Note
    Tuples can be converted into lists, and vice-versa.  The built-in tuple function takes a list and returns a tuple with the same elements, and the list function takes a tuple and returns a list.  In effect, tuple freezes a list, and list thaws a tuple.
-
    
-
    
-
    Further Reading on Tuples
    
-
 
    3.4. Declaring variables
    
 
    Now that you know something about dictionaries, tuples, and lists (oh my!), let's get back to the sample program from Chapter 2, odbchelper.py.
-
    Python has local and global variables like most other languages, but it has no explicit variable declarations.  Variables spring
+
    Python has local and global variables like most other languages, but it has no explicit variable declarations. Variables spring
    into existence by being assigned a value, and they are automatically destroyed when they go out of scope.
 
    Example 3.17. Defining the myParams Variable
     if __name__ == "__main__":
@@ -1299,19 +822,19 @@ if __name__ == "__main__":
                 "database":"master", \
                 "uid":"sa", \
                 "pwd":"secret" \
-                }
    Notice the indentation.  An if statement is a code block and needs to be indented just like a function.
+                }
    Notice the indentation. An if statement is a code block and needs to be indented just like a function.
 
    Also notice that the variable assignment is one command split over several lines, with a backslash (“\”) serving as a line-continuation marker.
-
    
 
    
 Note
 
    
 
    When a command is split among several lines with the line-continuation marker (“\”), the continued lines can be indented in any manner; Python's normally stringent indentation rules do not apply.  If your Python IDE auto-indents the continued line, you should probably accept its default unless you have a burning reason not to.
+When a command is split among several lines with the line-continuation marker (“\”), the continued lines can be indented in any manner; Python's normally stringent indentation rules do not apply. If your Python IDE auto-indents the continued line, you should probably accept its default unless you have a burning reason not to.
 
 
    
 
    
-
    Strictly speaking, expressions in parentheses, straight brackets, or curly braces (like defining a dictionary) can be split into multiple lines with or without the line continuation character (“\”).  I like to include the backslash even when it's not required because I think it makes the code easier to read, but that's
+
    Strictly speaking, expressions in parentheses, straight brackets, or curly braces (like defining a dictionary) can be split into multiple lines with or without the line continuation character (“\”). I like to include the backslash even when it's not required because I think it makes the code easier to read, but that's
 a matter of style.
-
    Third, you never declared the variable myParams, you just assigned a value to it.  This is like VBScript without the option explicit option.  Luckily, unlike VBScript, Python will not allow you to reference a variable that has never been assigned a value; trying to do so will raise an exception.
+
    Third, you never declared the variable myParams, you just assigned a value to it. This is like VBScript without the option explicit option. Luckily, unlike VBScript, Python will not allow you to reference a variable that has never been assigned a value; trying to do so will raise an exception.
 
    3.4.1. Referencing Variables
    
 
    Example 3.18. Referencing an Unbound Variable
    >>> x
 Traceback (innermost last):
@@ -1334,11 +857,11 @@ NameError: There is no variable named 'x'
 
 1 
 
-v is a tuple of three elements, and (x, y, z) is a tuple of three variables.  Assigning one to the other assigns each of the values of v to each of the variables, in order.
+v is a tuple of three elements, and (x, y, z) is a tuple of three variables. Assigning one to the other assigns each of the values of v to each of the variables, in order.
 
 
 
-
    This has all sorts of uses.  I often want to assign names to a range of values.  In C, you would use enum and manually list each constant and its associated value, which seems especially tedious when the values are consecutive.
+
    This has all sorts of uses. I often want to assign names to a range of values. In C, you would use enum and manually list each constant and its associated value, which seems especially tedious when the values are consecutive.
    In Python, you can use the built-in range function with multi-variable assignment to quickly assign consecutive values.
 
    Example 3.20. Assigning Consecutive Values
    >>> range(7)              1
 [0, 1, 2, 3, 4, 5, 6]
@@ -1353,14 +876,14 @@ NameError: There is no variable named 'x'
 
 1 
 
-The built-in range function returns a list of integers.  In its simplest form, it takes an upper limit and returns a zero-based list counting
-               up to but not including the upper limit.  (If you like, you can pass other parameters to specify a base other than 0 and a step other than 1.  You can print range.__doc__ for details.)
+The built-in range function returns a list of integers. In its simplest form, it takes an upper limit and returns a zero-based list counting
+               up to but not including the upper limit. (If you like, you can pass other parameters to specify a base other than 0 and a step other than 1. You can print range.__doc__ for details.)
 
 
 
 2 
 
-MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, and SUNDAY are the variables you're defining.  (This example came from the calendar module, a fun little module that prints calendars, like the UNIX program cal.  The calendar module defines integer constants for days of the week.)
+MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, and SUNDAY are the variables you're defining. (This example came from the calendar module, a fun little module that prints calendars, like the UNIX program cal. The calendar module defines integer constants for days of the week.)
 
 
 
@@ -1371,7 +894,7 @@ NameError: There is no variable named 'x'
 
 
 
    You can also use multi-variable assignment to build functions that return multiple values, simply by returning a tuple of
-   all the values.  The caller can treat it as a tuple, or assign the values to individual variables.  Many standard Python libraries do this, including the os module, which you'll discuss in Chapter 6.
+   all the values. The caller can treat it as a tuple, or assign the values to individual variables. Many standard Python libraries do this, including the os module, which you'll discuss in Chapter 6.
 
    
 
    Further Reading on Variables
    
 
      
@@ -1381,7 +904,7 @@ NameError: There is no variable named 'x'
 
 
    
 
    3.5. Formatting Strings
    
-
    Python supports formatting values into strings.  Although this can include very complicated expressions, the most basic usage is
+
    Python supports formatting values into strings. Although this can include very complicated expressions, the most basic usage is
    to insert values into a string with the %s placeholder.
 
@@ -1400,13 +923,13 @@ NameError: There is no variable named 'x'
-
    
 
    
 
    
 1 
 The whole expression evaluates to a string.  The first %s is replaced by the value of k; the second %s is replaced by the value of v.  All other characters in the string (in this case, the equal sign) stay as they are.
+The whole expression evaluates to a string. The first %s is replaced by the value of k; the second %s is replaced by the value of v. All other characters in the string (in this case, the equal sign) stay as they are.
 
 
    
 
    
-
    Note that (k, v) is a tuple.  I told you they were good for something.
+
    Note that (k, v) is a tuple. I told you they were good for something.
 
    You might be thinking that this is a lot of work just to do simple string concatentation, and you would be right, except that
-string formatting isn't just concatenation.  It's not even just formatting.  It's also type coercion.
+string formatting isn't just concatenation. It's not even just formatting. It's also type coercion.
 
    Example 3.22. String Formatting vs. Concatenating
    >>> uid = "sa"
 >>> pwd = "secret"
 >>> print pwd + " is not a good password for " + uid      1
@@ -1435,9 +958,9 @@ TypeError: cannot concatenate 'str' and 'int' objects
    3 
 
-(userCount, ) is a tuple with one element.  Yes, the syntax is a little strange, but there's a good reason for it: it's unambiguously a
-            tuple.  In fact, you can always include a comma after the last element when defining a list, tuple, or dictionary, but the
-            comma is required when defining a tuple with one element.  If the comma weren't required, Python wouldn't know whether (userCount) was a tuple with one element or just the value of userCount.
+(userCount, ) is a tuple with one element. Yes, the syntax is a little strange, but there's a good reason for it: it's unambiguously a
+            tuple. In fact, you can always include a comma after the last element when defining a list, tuple, or dictionary, but the
+            comma is required when defining a tuple with one element. If the comma weren't required, Python wouldn't know whether (userCount) was a tuple with one element or just the value of userCount.
 
 
 
@@ -1449,12 +972,12 @@ TypeError: cannot concatenate 'str' and 'int' objects
    5 
 
-Trying to concatenate a string with a non-string raises an exception.  Unlike string formatting, string concatenation works
+Trying to concatenate a string with a non-string raises an exception. Unlike string formatting, string concatenation works
             only when everything is already a string.
 
 
 
-
    As with printf in C, string formatting in Python is like a Swiss Army knife.  There are options galore, and modifier strings to specially format many different types of values.
+
    As with printf in C, string formatting in Python is like a Swiss Army knife. There are options galore, and modifier strings to specially format many different types of values.
 
    Example 3.23. Formatting Numbers
     >>> print "Today's stock price: %f" % 50.4625   1
 50.462500
@@ -1479,7 +1002,7 @@ TypeError: cannot concatenate 'str' and 'int' objects
    3 
 
-You can even combine modifiers.  Adding the + modifier displays a plus or minus sign before the value.   Note that the ".2" modifier is still in place, and is padding
+You can even combine modifiers. Adding the + modifier displays a plus or minus sign before the value.  Note that the ".2" modifier is still in place, and is padding
             the value to exactly two decimal places.
 
 
@@ -1507,7 +1030,7 @@ TypeError: cannot concatenate 'str' and 'int' objects
    1 
 
-To make sense of this, look at it from right to left.  li is the list you're mapping.  Python loops through li one element at a time, temporarily assigning the value of each element to the variable elem.  Python then applies the function elem*2 and appends that result to the returned list.
+To make sense of this, look at it from right to left. li is the list you're mapping. Python loops through li one element at a time, temporarily assigning the value of each element to the variable elem. Python then applies the function elem*2 and appends that result to the returned list.
 
 
 
@@ -1518,13 +1041,13 @@ TypeError: cannot concatenate 'str' and 'int' objects
    3 
 
-It is safe to assign the result of a list comprehension to the variable that you're mapping.  Python constructs the new list in memory, and when the list comprehension is complete, it assigns the result to the variable.
+It is safe to assign the result of a list comprehension to the variable that you're mapping. Python constructs the new list in memory, and when the list comprehension is complete, it assigns the result to the variable.
 
 
 
 
    
 
    Here are the list comprehensions in the buildConnectionString function that you declared in Chapter 2:
    -["%s=%s" % (k, v) for k, v in params.items()]
    First, notice that you're calling the items function of the params dictionary.  This function returns a list of tuples of all the data in the dictionary.
+["%s=%s" % (k, v) for k, v in params.items()]
    First, notice that you're calling the items function of the params dictionary. This function returns a list of tuples of all the data in the dictionary.
 
    Example 3.25. The keys, values, and items Functions
    >>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
 >>> params.keys()   1
 ['server', 'uid', 'database', 'pwd']
@@ -1536,24 +1059,24 @@ TypeError: cannot concatenate 'str' and 'int' objects
    1 
 
-The keys method of a dictionary returns a list of all the keys.  The list is not in the order in which the dictionary was defined
+The keys method of a dictionary returns a list of all the keys. The list is not in the order in which the dictionary was defined
             (remember that elements in a dictionary are unordered), but it is a list.
 
 
 
 2 
 
-The values method returns a list of all the values.  The list is in the same order as the list returned by keys, so params.values()[n] == params[params.keys()[n]] for all values of n.
+The values method returns a list of all the values. The list is in the same order as the list returned by keys, so params.values()[n] == params[params.keys()[n]] for all values of n.
 
 
 
 3 
 
-The items method returns a list of tuples of the form (key, value).  The list contains all the data in the dictionary.
+The items method returns a list of tuples of the form (key, value). The list contains all the data in the dictionary.
 
 
 
-
    Now let's see what buildConnectionString does.  It takes a list, params.items(), and maps it to a new list by applying string formatting to each element.  The new list will have the same number of elements
+
    Now let's see what buildConnectionString does. It takes a list, params.items(), and maps it to a new list by applying string formatting to each element. The new list will have the same number of elements
 as params.items(), but each element in the new list will be a string that contains both a key and its associated value from the params dictionary.
 
    Example 3.26. List Comprehensions in buildConnectionString, Step by Step
    >>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
 >>> params.items()
@@ -1568,7 +1091,7 @@ as params.items(), but each element in the
 
 1 
 
-Note that you're using two variables to iterate through the params.items() list.  This is another use of multi-variable assignment.  The first element of params.items() is ('server', 'mpilgrim'), so in the first iteration of the list comprehension, k will get 'server' and v will get 'mpilgrim'.  In this case, you're ignoring the value of v and only including the value of k in the returned list, so this list comprehension ends up being equivalent to params.keys().
+Note that you're using two variables to iterate through the params.items() list. This is another use of multi-variable assignment. The first element of params.items() is ('server', 'mpilgrim'), so in the first iteration of the list comprehension, k will get 'server' and v will get 'mpilgrim'. In this case, you're ignoring the value of v and only including the value of k in the returned list, so this list comprehension ends up being equivalent to params.keys().
 
 
 
@@ -1580,8 +1103,8 @@ as params.items(), but each element in the
 
 3 
 
-Combining the previous two examples with some simple string formatting, you get a list of strings that include both the key and value of each element of the dictionary.  This looks suspiciously
-            like the output of the program.  All that remains is to join the elements in this list into a single string.
+Combining the previous two examples with some simple string formatting, you get a list of strings that include both the key and value of each element of the dictionary. This looks suspiciously
+            like the output of the program. All that remains is to join the elements in this list into a single string.
 
 
 
@@ -1594,18 +1117,18 @@ as params.items(), but each element in the
 
 
 
    3.7. Joining Lists and Splitting Strings
    
-
    You have a list of key-value pairs in the form key=value, and you want to join them into a single string.  To join any list of strings into a single string, use the join method of a string object.
+
    You have a list of key-value pairs in the form key=value, and you want to join them into a single string. To join any list of strings into a single string, use the join method of a string object.
 
    
 
    Here is an example of joining a list from the buildConnectionString function:
    -    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])
    One interesting note before you continue.  I keep repeating that functions are objects, strings are objects... everything
-is an object.  You might have thought I meant that string variables are objects.  But no, look closely at this example and you'll see that the string ";" itself is an object, and you are calling its join method.
-
    The join method joins the elements of the list into a single string, with each element separated by a semi-colon.  The delimiter doesn't
-need to be a semi-colon; it doesn't even need to be a single character.  It can be any string.
+    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])
    One interesting note before you continue. I keep repeating that functions are objects, strings are objects... everything
+is an object. You might have thought I meant that string variables are objects. But no, look closely at this example and you'll see that the string ";" itself is an object, and you are calling its join method.
+
    The join method joins the elements of the list into a single string, with each element separated by a semi-colon. The delimiter doesn't
+need to be a semi-colon; it doesn't even need to be a single character. It can be any string.
    
-
@@ -1616,7 +1139,7 @@ need to be a semi-colon; it doesn't even need to be a single character.  It can
 >>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
 'server=mpilgrim;uid=sa;database=master;pwd=secret'
    This string is then returned from the odbchelper function and printed by the calling block, which gives you the output that you marveled at when you started reading this
 chapter.
-
    You're probably wondering if there's an analogous method to split a string into a list.  And of course there is, and it's
+
    You're probably wondering if there's an analogous method to split a string into a list. And of course there is, and it's
 called split.
 
    Example 3.28. Splitting a String
    >>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
 >>> s = ";".join(li)
@@ -1630,13 +1153,13 @@ called split.
 
    
-
-
    
 
    
 Caution
 
    
 
    join works only on lists of strings; it does not do any type coercion.  Joining a list that has one or more non-string elements
+join works only on lists of strings; it does not do any type coercion. Joining a list that has one or more non-string elements
       will raise an exception.
 
 
    
 1 
 split reverses join by splitting a string into a multi-element list.  Note that the delimiter (“;”) is stripped out completely; it does not appear in any of the elements of the returned list.
+split reverses join by splitting a string into a multi-element list. Note that the delimiter (“;”) is stripped out completely; it does not appear in any of the elements of the returned list.
 
 
    
 
    
 2 
 split takes an optional second argument, which is the number of times to split.  (“Oooooh, optional arguments...”  You'll learn how to do this in your own functions in the next chapter.)
+split takes an optional second argument, which is the number of times to split. (“Oooooh, optional arguments...”  You'll learn how to do this in your own functions in the next chapter.)
 
 
    
 
    
@@ -1663,10 +1186,10 @@ called split.
 
 
 
    3.7.1. Historical Note on String Methods
    
-
    When I first learned Python, I expected join to be a method of a list, which would take the delimiter as an argument.  Many people feel the same way, and there's a story
-   behind the join method.  Prior to Python 1.6, strings didn't have all these useful methods.  There was a separate string module that contained all the string functions; each function took a string as its first argument.  The functions were deemed
-   important enough to put onto the strings themselves, which made sense for functions like lower, upper, and split.  But many hard-core Python programmers objected to the new join method, arguing that it should be a method of the list instead, or that it shouldn't move at all but simply stay a part of
-   the old string module (which still has a lot of useful stuff in it).  I use the new join method exclusively, but you will see code written either way, and if it really bothers you, you can use the old string.join function instead.
+
    When I first learned Python, I expected join to be a method of a list, which would take the delimiter as an argument. Many people feel the same way, and there's a story
+   behind the join method. Prior to Python 1.6, strings didn't have all these useful methods. There was a separate string module that contained all the string functions; each function took a string as its first argument. The functions were deemed
+   important enough to put onto the strings themselves, which made sense for functions like lower, upper, and split. But many hard-core Python programmers objected to the new join method, arguing that it should be a method of the list instead, or that it shouldn't move at all but simply stay a part of
+   the old string module (which still has a lot of useful stuff in it). I use the new join method exclusively, but you will see code written either way, and if it really bothers you, you can use the old string.join function instead.
 
    3.8. Summary
    
 
    The odbchelper.py program and its output should now make perfect sense.
 
    @@ -1705,12 +1228,12 @@ if __name__ == "__main__":
 
 
    
 
    Chapter 4. The Power Of Introspection
    
-
    This chapter covers one of Python's strengths: introspection.  As you know, everything in Python is an object, and introspection is code looking at other modules and functions in memory as objects, getting information about them, and
-manipulating them.  Along the way, you'll define functions with no name, call functions with arguments out of order, and reference
+
    This chapter covers one of Python's strengths: introspection. As you know, everything in Python is an object, and introspection is code looking at other modules and functions in memory as objects, getting information about them, and
+manipulating them. Along the way, you'll define functions with no name, call functions with arguments out of order, and reference
 functions whose names you don't even know ahead of time.
 
    4.1. Diving In
    
-
    Here is a complete, working Python program.  You should understand a good deal about it just by looking at it.  The numbered lines illustrate concepts covered
-   in Chapter 2, Your First Python Program.  Don't worry if the rest of the code looks intimidating; you'll learn all about it throughout this chapter.
+
    Here is a complete, working Python program. You should understand a good deal about it just by looking at it. The numbered lines illustrate concepts covered
+   in Chapter 2, Your First Python Program. Don't worry if the rest of the code looks intimidating; you'll learn all about it throughout this chapter.
 
    Example 4.1. apihelper.py
    
 
    If you have not already done so, you can download this and other examples used in this book.
     def info(object, spacing=10, collapse=1): 1 2 3
@@ -1730,13 +1253,13 @@ if __name__ == "__main__":                1 
 
-This module has one function, info.  According to its function declaration, it takes three parameters: object, spacing, and collapse.  The last two are actually optional parameters, as you'll see shortly.
+This module has one function, info. According to its function declaration, it takes three parameters: object, spacing, and collapse. The last two are actually optional parameters, as you'll see shortly.
 
 
 
 2 
 
-The info function has a multi-line docstring that succinctly describes the function's purpose.  Note that no return value is mentioned; this function will be used solely
+The info function has a multi-line docstring that succinctly describes the function's purpose. Note that no return value is mentioned; this function will be used solely
             for its effects, rather than its value.
 
 
@@ -1760,7 +1283,7 @@ if __name__ == "__main__":                
    Example 4.2. Sample Usage of apihelper.py
    >>> from apihelper import info
 >>> li = []
@@ -1773,7 +1296,7 @@ insert     L.insert(index, object) -- insert object before index
 pop        L.pop([index]) -> item -- remove and return item at index (default last)
 remove     L.remove(value) -- remove first occurrence of value
 reverse    L.reverse() -- reverse *IN PLACE*
-sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
    By default the output is formatted to be easy to read.  Multi-line docstrings are collapsed into a single long line, but this option can be changed by specifying 0 for the collapse argument.  If the function names are longer than 10 characters, you can specify a larger value for the spacing argument to make the output easier to read.
+sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
    By default the output is formatted to be easy to read. Multi-line docstrings are collapsed into a single long line, but this option can be changed by specifying 0 for the collapse argument. If the function names are longer than 10 characters, you can specify a larger value for the spacing argument to make the output easier to read.
 
    Example 4.3. Advanced Usage of apihelper.py
    >>> import odbchelper
 >>> info(odbchelper)
 buildConnectionString Build a connection string from a dictionary Returns string.
@@ -1785,11 +1308,11 @@ buildConnectionString          Build a connection string from a dictionary Retur
     Returns string.
 
    4.2. Using Optional and Named Arguments
    
 
    Python allows function arguments to have default values; if the function is called without the argument, the argument gets its default
-   value.  Futhermore, arguments can be specified in any order by using named arguments.  Stored procedures in SQL Server Transact/SQL can do this, so if you're a SQL Server scripting guru, you can skim this part.
+   value. Futhermore, arguments can be specified in any order by using named arguments. Stored procedures in SQL Server Transact/SQL can do this, so if you're a SQL Server scripting guru, you can skim this part.
 
    
 
    Here is an example of info, a function with two optional arguments:
    -def info(object, spacing=10, collapse=1):
    spacing and collapse are optional, because they have default values defined.  object is required, because it has no default value.  If info is called with only one argument, spacing defaults to 10 and collapse defaults to 1.  If info is called with two arguments, collapse still defaults to 1.
-
    Say you want to specify a value for collapse but want to accept the default value for spacing.  In most languages, you would be out of luck, because you would need to call the function with three arguments.  But in
+def info(object, spacing=10, collapse=1):
    spacing and collapse are optional, because they have default values defined. object is required, because it has no default value. If info is called with only one argument, spacing defaults to 10 and collapse defaults to 1. If info is called with two arguments, collapse still defaults to 1.
+
    Say you want to specify a value for collapse but want to accept the default value for spacing. In most languages, you would be out of luck, because you would need to call the function with three arguments. But in
 Python, arguments can be specified by name, in any order.
 
    Example 4.4. Valid Calls of info
     info(odbchelper)  1
@@ -1812,7 +1335,7 @@ info(spacing=15, object=odbchelper) 3 
 
-Here you are naming the collapse argument explicitly and specifying its value.  spacing still gets its default value of 10.
+Here you are naming the collapse argument explicitly and specifying its value. spacing still gets its default value of 10.
 
 
 
@@ -1822,7 +1345,7 @@ info(spacing=15, object=odbchelper) 
 
 Note
@@ -1840,11 +1363,11 @@ time, you'll call functions the “normal” way, but you always have th
 
 
 
    4.3. Using type, str, dir, and Other Built-In Functions
    
-
    Python has a small set of extremely useful built-in functions.  All other functions are partitioned off into modules.  This was
+
    Python has a small set of extremely useful built-in functions. All other functions are partitioned off into modules. This was
    actually a conscious design decision, to keep the core language from getting bloated like other scripting languages (cough
    cough, Visual Basic).
 
    4.3.1. The type Function
    
-
    The type function returns the datatype of any arbitrary object.  The possible types are listed in the types module.  This is useful for helper functions that can handle several types of data.
+
    The type function returns the datatype of any arbitrary object. The possible types are listed in the types module. This is useful for helper functions that can handle several types of data.
 
    Example 4.5. Introducing type
    >>> type(1)           1
 <type 'int'>
 >>> li = []
@@ -1860,7 +1383,7 @@ True
    
 
 1 
 
-type takes anything -- and I mean anything -- and returns its datatype.  Integers, strings, lists, dictionaries, tuples, functions,
+type takes anything -- and I mean anything -- and returns its datatype. Integers, strings, lists, dictionaries, tuples, functions,
                classes, modules, even types are acceptable.
 
 
@@ -1879,12 +1402,12 @@ True
    
 
 4 
 
-You can use the constants in the types module to compare types of objects.  This is what the info function does, as you'll see shortly.
+You can use the constants in the types module to compare types of objects. This is what the info function does, as you'll see shortly.
 
 
 
 
    4.3.2. The str Function
    
-
    The str coerces data into a string.  Every datatype can be coerced into a string.
+
    The str coerces data into a string. Every datatype can be coerced into a string.
 
    Example 4.6. Introducing str
     >>> str(1)          1
 '1'
@@ -1908,24 +1431,24 @@ True
    
 
 2 
 
-However, str works on any object of any type.  Here it works on a list which you've constructed in bits and pieces.
+However, str works on any object of any type. Here it works on a list which you've constructed in bits and pieces.
 
 
 
 3 
 
-str also works on modules.  Note that the string representation of the module includes the pathname of the module on disk, so
+str also works on modules. Note that the string representation of the module includes the pathname of the module on disk, so
                yours will be different.
 
 
 
 4 
 
-A subtle but important behavior of str is that it works on None, the Python null value.  It returns the string 'None'.  You'll use this to your advantage in the info function, as you'll see shortly.
+A subtle but important behavior of str is that it works on None, the Python null value. It returns the string 'None'. You'll use this to your advantage in the info function, as you'll see shortly.
 
 
 
-
    At the heart of the info function is the powerful dir function.  dir returns a list of the attributes and methods of any object: modules, functions, strings, lists, dictionaries... pretty much
+
    At the heart of the info function is the powerful dir function. dir returns a list of the attributes and methods of any object: modules, functions, strings, lists, dictionaries... pretty much
    anything.
 
    Example 4.7. Introducing dir
    >>> li = []
 >>> dir(li)           1
@@ -1941,24 +1464,24 @@ True
    
 
 1 
 
-li is a list, so dir(li) returns a list of all the methods of a list.  Note that the returned list contains the names of the methods as strings, not
+li is a list, so dir(li) returns a list of all the methods of a list. Note that the returned list contains the names of the methods as strings, not
                the methods themselves.
 
 
 
 2 
 
-d is a dictionary, so dir(d) returns a list of the names of dictionary methods.  At least one of these, keys, should look familiar.
+d is a dictionary, so dir(d) returns a list of the names of dictionary methods. At least one of these, keys, should look familiar.
 
 
 
 3 
 
-This is where it really gets interesting. odbchelper is a module, so dir(odbchelper) returns a list of all kinds of stuff defined in the module, including built-in attributes, like __name__, __doc__, and whatever other attributes and methods you define.  In this case, odbchelper has only one user-defined method, the buildConnectionString function described in Chapter 2.
+This is where it really gets interesting. odbchelper is a module, so dir(odbchelper) returns a list of all kinds of stuff defined in the module, including built-in attributes, like __name__, __doc__, and whatever other attributes and methods you define. In this case, odbchelper has only one user-defined method, the buildConnectionString function described in Chapter 2.
 
 
 
-
    Finally, the callable function takes any object and returns True if the object can be called, or False otherwise.  Callable objects include functions, class methods, even classes themselves.  (More on classes in the next chapter.)
+
    Finally, the callable function takes any object and returns True if the object can be called, or False otherwise. Callable objects include functions, class methods, even classes themselves. (More on classes in the next chapter.)
 
    Example 4.8. Introducing callable
     >>> import string
 >>> string.punctuation           1
@@ -1973,7 +1496,7 @@ True
 join(list [,sep]) -> string
 
     Return a string composed of the words in list, with
-    intervening occurrences of sep.  The default separator is a
+    intervening occurrences of sep. The default separator is a
     single space.
 
     (joinfields and join are synonymous)
    
@@ -1993,7 +1516,7 @@ True
 
 3 
 
-string.punctuation is not callable; it is a string.  (A string does have callable methods, but the string itself is not callable.)
+string.punctuation is not callable; it is a string. (A string does have callable methods, but the string itself is not callable.)
 
 
 
@@ -2005,15 +1528,15 @@ True
 
 5 
 
-Any callable object may have a docstring.  By using the callable function on each of an object's attributes, you can determine which attributes you care about (methods, functions, classes)
+Any callable object may have a docstring. By using the callable function on each of an object's attributes, you can determine which attributes you care about (methods, functions, classes)
                and which you want to ignore (constants and so on) without knowing anything about the object ahead of time.
 
 
 
 
    4.3.3. Built-In Functions
    
-
    type, str, dir, and all the rest of Python's built-in functions are grouped into a special module called __builtin__.  (That's two underscores before and after.)  If it helps, you can think of Python automatically executing from __builtin__ import * on startup, which imports all the “built-in” functions into the namespace so you can use them directly.
+
    type, str, dir, and all the rest of Python's built-in functions are grouped into a special module called __builtin__. (That's two underscores before and after.)  If it helps, you can think of Python automatically executing from __builtin__ import * on startup, which imports all the “built-in” functions into the namespace so you can use them directly.
 
    The advantage of thinking like this is that you can access all the built-in functions and attributes as a group by getting
-   information about the __builtin__ module.  And guess what, Python has a function called info.  Try it yourself and skim through the list now.  We'll dive into some of the more important functions later.  (Some of the
+   information about the __builtin__ module. And guess what, Python has a function called info. Try it yourself and skim through the list now. We'll dive into some of the more important functions later. (Some of the
    built-in error classes, like AttributeError, should already look familiar.)
 
    Example 4.9. Built-in Attributes and Functions
    >>> from apihelper import info
 >>> import __builtin__
@@ -2032,7 +1555,7 @@ IOError              I/O operation failed.
 Note
 
 
-Python comes with excellent reference manuals, which you should peruse thoroughly to learn all the modules Python has to offer.  But unlike most languages, where you would find yourself referring back to the manuals or man pages to remind
+Python comes with excellent reference manuals, which you should peruse thoroughly to learn all the modules Python has to offer. But unlike most languages, where you would find yourself referring back to the manuals or man pages to remind
          yourself how to use these modules, Python is largely self-documenting.
 
 
@@ -2044,7 +1567,7 @@ IOError              I/O operation failed.
 
 
 
    4.4. Getting Object References With getattr
    
-
    You already know that Python functions are objects.  What you don't know is that you can get a reference to a function without knowing its name until run-time, by using the
+
    You already know that Python functions are objects. What you don't know is that you can get a reference to a function without knowing its name until run-time, by using the
 getattr function.
 
    Example 4.10. Introducing getattr
    >>> li = ["Larry", "Curly"]
 >>> li.pop     1
@@ -2064,20 +1587,20 @@ AttributeError: 'tuple' object has no attribute 'pop'
    1 
 
-This gets a reference to the pop method of the list.  Note that this is not calling the pop method; that would be li.pop().  This is the method itself.
+This gets a reference to the pop method of the list. Note that this is not calling the pop method; that would be li.pop(). This is the method itself.
 
 
 
 2 
 
-This also returns a reference to the pop method, but this time, the method name is specified as a string argument to the getattr function.  getattr is an incredibly useful built-in function that returns any attribute of any object.  In this case, the object is a list,
+This also returns a reference to the pop method, but this time, the method name is specified as a string argument to the getattr function. getattr is an incredibly useful built-in function that returns any attribute of any object. In this case, the object is a list,
             and the attribute is the pop method.
 
 
 
 3 
 
-In case it hasn't sunk in just how incredibly useful this is, try this: the return value of getattr is the method, which you can then call just as if you had said li.append("Moe") directly.  But you didn't call the function directly; you specified the function name as a string instead.
+In case it hasn't sunk in just how incredibly useful this is, try this: the return value of getattr is the method, which you can then call just as if you had said li.append("Moe") directly. But you didn't call the function directly; you specified the function name as a string instead.
 
 
 
@@ -2094,7 +1617,7 @@ AttributeError: 'tuple' object has no attribute 'pop'
    Example 4.11. The getattr Function in apihelper.py
    >>> import odbchelper
 >>> odbchelper.buildConnectionString             1
 <function buildConnectionString at 00D18DD4>
@@ -2115,19 +1638,19 @@ True
    
 
 1 
 
-This returns a reference to the buildConnectionString function in the odbchelper module, which you studied in Chapter 2, Your First Python Program.  (The hex address you see is specific to my machine; your output will be different.)
+This returns a reference to the buildConnectionString function in the odbchelper module, which you studied in Chapter 2, Your First Python Program. (The hex address you see is specific to my machine; your output will be different.)
 
 
 
 2 
 
-Using getattr, you can get the same reference to the same function.  In general, getattr(object, "attribute") is equivalent to object.attribute.  If object is a module, then attribute can be anything defined in the module: a function, class, or global variable.
+Using getattr, you can get the same reference to the same function. In general, getattr(object, "attribute") is equivalent to object.attribute. If object is a module, then attribute can be anything defined in the module: a function, class, or global variable.
 
 
 
 3 
 
-And this is what you actually use in the info function.  object is passed into the function as an argument; method is a string which is the name of a method or function.
+And this is what you actually use in the info function. object is passed into the function as an argument; method is a string which is the name of a method or function.
 
 
 
@@ -2144,10 +1667,10 @@ True
    
 
 
 
    4.4.2. getattr As a Dispatcher
    
-
    A common usage pattern of getattr is as a dispatcher.  For example, if you had a program that could output data in a variety of different formats, you could
+
    A common usage pattern of getattr is as a dispatcher. For example, if you had a program that could output data in a variety of different formats, you could
    define separate functions for each output format and use a single dispatch function to call the right one.
-
    For example, let's imagine a program that prints site statistics in HTML, XML, and plain text formats.  The choice of output format could be specified on the command line, or stored in a configuration
-   file.  A statsout module defines three functions, output_html, output_xml, and output_text.  Then the main program defines a single output function, like this:
+
    For example, let's imagine a program that prints site statistics in HTML, XML, and plain text formats. The choice of output format could be specified on the command line, or stored in a configuration
+   file. A statsout module defines three functions, output_html, output_xml, and output_text. Then the main program defines a single output function, like this:
 
    Example 4.12. Creating a Dispatcher with getattr
     import statsout
 
@@ -2159,25 +1682,25 @@ def output(data, format="text"):            
 1 
 
-The output function takes one required argument, data, and one optional argument, format.  If format is not specified, it defaults to text, and you will end up calling the plain text output function.
+The output function takes one required argument, data, and one optional argument, format. If format is not specified, it defaults to text, and you will end up calling the plain text output function.
 
 
 
 2 
 
-You concatenate the format argument with "output_" to produce a function name, and then go get that function from the statsout module.  This allows you to easily extend the program later to support other output formats, without changing this dispatch
-            function.  Just add another function to statsout named, for instance, output_pdf, and pass "pdf" as the format into the output function.
+You concatenate the format argument with "output_" to produce a function name, and then go get that function from the statsout module. This allows you to easily extend the program later to support other output formats, without changing this dispatch
+            function. Just add another function to statsout named, for instance, output_pdf, and pass "pdf" as the format into the output function.
 
 
 
 3 
 
-Now you can simply call the output function in the same way as any other function.  The output_function variable is a reference to the appropriate function from the statsout module.
+Now you can simply call the output function in the same way as any other function. The output_function variable is a reference to the appropriate function from the statsout module.
 
 
 
 
    Did you see the bug in the previous example?  This is a very loose coupling of strings and functions, and there is no error
-   checking.  What happens if the user passes in a format that doesn't have a corresponding function defined in statsout?  Well, getattr will return None, which will be assigned to output_function instead of a valid function, and the next line that attempts to call that function will crash and raise an exception.  That's
+   checking. What happens if the user passes in a format that doesn't have a corresponding function defined in statsout?  Well, getattr will return None, which will be assigned to output_function instead of a valid function, and the next line that attempts to call that function will crash and raise an exception. That's
    bad.
 
    Luckily, getattr takes an optional third argument, a default value.
 
    Example 4.13. getattr Default Values
    @@ -2191,17 +1714,17 @@ def output(data, format="text"):
 
 1 
 
-This function call is guaranteed to work, because you added a third argument to the call to getattr.  The third argument is a default value that is returned if the attribute or method specified by the second argument wasn't
+This function call is guaranteed to work, because you added a third argument to the call to getattr. The third argument is a default value that is returned if the attribute or method specified by the second argument wasn't
                found.
 
 
 
-
    As you can see, getattr is quite powerful.  It is the heart of introspection, and you'll see even more powerful examples of it in later chapters.
+
    As you can see, getattr is quite powerful. It is the heart of introspection, and you'll see even more powerful examples of it in later chapters.
 
    4.5. Filtering Lists
    
-
    As you know, Python has powerful capabilities for mapping lists into other lists, via list comprehensions (Section 3.6, “Mapping Lists”).  This can be combined with a filtering mechanism, where some elements in the list are mapped while others are skipped entirely.
+
    As you know, Python has powerful capabilities for mapping lists into other lists, via list comprehensions (Section 3.6, “Mapping Lists”). This can be combined with a filtering mechanism, where some elements in the list are mapped while others are skipped entirely.
 
    
 
    Here is the list filtering syntax:
    -[mapping-expression for element in source-list if filter-expression]
    This is an extension of the list comprehensions that you know and love.  The first two thirds are the same; the last part, starting with the if, is the filter expression.  A filter expression can be any expression that evaluates true or false (which in Python can be almost anything).  Any element for which the filter expression evaluates true will be included in the mapping.  All other elements are ignored,
+[mapping-expression for element in source-list if filter-expression]
    This is an extension of the list comprehensions that you know and love. The first two thirds are the same; the last part, starting with the if, is the filter expression. A filter expression can be any expression that evaluates true or false (which in Python can be almost anything). Any element for which the filter expression evaluates true will be included in the mapping. All other elements are ignored,
 so they are never put through the mapping expression and are not included in the output list.
 
    Example 4.14. Introducing List Filtering
    >>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
 >>> [elem for elem in li if len(elem) > 1]       1
@@ -2215,35 +1738,35 @@ so they are never put through the mapping expression and are not included in the
 1 
 
 The mapping expression here is simple (it just returns the value of each element), so concentrate on the filter expression.
-             As Python loops through the list, it runs each element through the filter expression.  If the filter expression is true, the element
-            is mapped and the result of the mapping expression is included in the returned list.  Here, you are filtering out all the
+             As Python loops through the list, it runs each element through the filter expression. If the filter expression is true, the element
+            is mapped and the result of the mapping expression is included in the returned list. Here, you are filtering out all the
             one-character strings, so you're left with a list of all the longer strings.
 
 
 
 2 
 
-Here, you are filtering out a specific value, b.  Note that this filters all occurrences of b, since each time it comes up, the filter expression will be false.
+Here, you are filtering out a specific value, b. Note that this filters all occurrences of b, since each time it comes up, the filter expression will be false.
 
 
 
 3 
 
-count is a list method that returns the number of times a value occurs in a list.  You might think that this filter would eliminate
-            duplicates from a list, returning a list containing only one copy of each value in the original list.  But it doesn't, because
-            values that appear twice in the original list (in this case, b and d) are excluded completely.  There are ways of eliminating duplicates from a list, but filtering is not the solution.
+count is a list method that returns the number of times a value occurs in a list. You might think that this filter would eliminate
+            duplicates from a list, returning a list containing only one copy of each value in the original list. But it doesn't, because
+            values that appear twice in the original list (in this case, b and d) are excluded completely. There are ways of eliminating duplicates from a list, but filtering is not the solution.
 
 
 
 
    Let's id="apihelper.filter.care" get back to this line from apihelper.py:
    -    methodList = [method for method in dir(object) if callable(getattr(object, method))]
    This looks complicated, and it is complicated, but the basic structure is the same.  The whole filter expression returns a
-list, which is assigned to the methodList variable.  The first half of the expression is the list mapping part.  The mapping expression is an identity expression,
-which it returns the value of each element.  dir(object) returns a list of object's attributes and methods -- that's the list you're mapping.  So the only new part is the filter expression after the if.
-
    The filter expression looks scary, but it's not.  You already know about callable, getattr, and in.  As you saw in the previous section, the expression getattr(object, method) returns a function object if object is a module and method is the name of a function in that module.
-
    So this expression takes an object (named object).  Then it gets a list of the names of the object's attributes, methods, functions, and a few other things.  Then it filters
-that list to weed out all the stuff that you don't care about.  You do the weeding out by taking the name of each attribute/method/function
-and getting a reference to the real thing, via the getattr function.  Then you check to see if that object is callable, which will be any methods and functions, both built-in (like
-the pop method of a list) and user-defined (like the buildConnectionString function of the odbchelper module).  You don't care about other attributes, like the __name__ attribute that's built in to every module.
+    methodList = [method for method in dir(object) if callable(getattr(object, method))]
    This looks complicated, and it is complicated, but the basic structure is the same. The whole filter expression returns a
+list, which is assigned to the methodList variable. The first half of the expression is the list mapping part. The mapping expression is an identity expression,
+which it returns the value of each element. dir(object) returns a list of object's attributes and methods -- that's the list you're mapping. So the only new part is the filter expression after the if.
+
    The filter expression looks scary, but it's not. You already know about callable, getattr, and in. As you saw in the previous section, the expression getattr(object, method) returns a function object if object is a module and method is the name of a function in that module.
+
    So this expression takes an object (named object). Then it gets a list of the names of the object's attributes, methods, functions, and a few other things. Then it filters
+that list to weed out all the stuff that you don't care about. You do the weeding out by taking the name of each attribute/method/function
+and getting a reference to the real thing, via the getattr function. Then you check to see if that object is callable, which will be any methods and functions, both built-in (like
+the pop method of a list) and user-defined (like the buildConnectionString function of the odbchelper module). You don't care about other attributes, like the __name__ attribute that's built in to every module.
 
    
 
    Further Reading on Filtering Lists
    
 
      
@@ -2263,15 +1786,15 @@ the pop method of a list) and user-defined (like the buildCon
 
 1 
 
-When using and, values are evaluated in a boolean context from left to right.  0, '', [], (), {}, and None are false in a boolean context; everything else is true.  Well, almost everything.  By default, instances of classes are
-            true in a boolean context, but you can define special methods in your class to make an instance evaluate to false.  You'll
-            learn all about classes and special methods in Chapter 5.  If all values are true in a boolean context, and returns the last value.  In this case, and evaluates 'a', which is true, then 'b', which is true, and returns 'b'.
+When using and, values are evaluated in a boolean context from left to right. 0, '', [], (), {}, and None are false in a boolean context; everything else is true. Well, almost everything. By default, instances of classes are
+            true in a boolean context, but you can define special methods in your class to make an instance evaluate to false. You'll
+            learn all about classes and special methods in Chapter 5. If all values are true in a boolean context, and returns the last value. In this case, and evaluates 'a', which is true, then 'b', which is true, and returns 'b'.
 
 
 
 2 
 
-If any value is false in a boolean context, and returns the first false value.  In this case, '' is the first false value.
+If any value is false in a boolean context, and returns the first false value. In this case, '' is the first false value.
 
 
 
@@ -2288,15 +1811,15 @@ the pop method of a list) and user-defined (like the buildCon
 >>> '' or [] or {}      3
 {}
 >>> def sidefx():
-...     print "in sidefx()"
-...     return 1
+...    print "in sidefx()"
+...    return 1
 >>> 'a' or sidefx()     4
 'a'
    
 
-
@@ -2308,18 +1831,18 @@ the pop method of a list) and user-defined (like the buildCon
 
-
-
    
 
    
 1 
 When using or, values are evaluated in a boolean context from left to right, just like and.  If any value is true, or returns that value immediately.  In this case, 'a' is the first true value.
+When using or, values are evaluated in a boolean context from left to right, just like and. If any value is true, or returns that value immediately. In this case, 'a' is the first true value.
 
 
    
 
    
 3 
 If all values are false, or returns the last value.  or evaluates '', which is false, then [], which is false, then {}, which is false, and returns {}.
+If all values are false, or returns the last value. or evaluates '', which is false, then [], which is false, then {}, which is false, and returns {}.
 
 
    
 
    
 4 
 Note that or evaluates values only until it finds one that is true in a boolean context, and then it ignores the rest.  This distinction
-            is important if some values can have side effects.  Here, the function sidefx is never called, because or evaluates 'a', which is true, and returns 'a' immediately.
+Note that or evaluates values only until it finds one that is true in a boolean context, and then it ignores the rest. This distinction
+            is important if some values can have side effects. Here, the function sidefx is never called, because or evaluates 'a', which is true, and returns 'a' immediately.
 
 
    
 
    
-
    If you're a C hacker, you are certainly familiar with the bool ? a : b expression, which evaluates to a if bool is true, and b otherwise.  Because of the way and and or work in Python, you can accomplish the same thing.
+
    If you're a C hacker, you are certainly familiar with the bool ? a : b expression, which evaluates to a if bool is true, and b otherwise. Because of the way and and or work in Python, you can accomplish the same thing.
 
    4.6.1. Using the and-or Trick
    
 
    Example 4.17. Introducing the and-or Trick
    >>> a = "first"
 >>> b = "second"
@@ -2332,7 +1855,7 @@ the pop method of a list) and user-defined (like the buildCon
 
 1 
 
-This syntax looks similar to the bool ? a : b expression in C.  The entire expression is evaluated from left to right, so the and is evaluated first.  1 and 'first' evalutes to 'first', then 'first' or 'second' evalutes to 'first'.
+This syntax looks similar to the bool ? a : b expression in C. The entire expression is evaluated from left to right, so the and is evaluated first. 1 and 'first' evalutes to 'first', then 'first' or 'second' evalutes to 'first'.
 
 
 
@@ -2343,7 +1866,7 @@ the pop method of a list) and user-defined (like the buildCon
 
 
 
    However, since this Python expression is simply boolean logic, and not a special construct of the language, there is one extremely important difference
-   between this and-or trick in Python and the bool ? a : b syntax in C.  If the value of a is false, the expression will not work as you would expect it to.  (Can you tell I was bitten by this?  More than once?)
+   between this and-or trick in Python and the bool ? a : b syntax in C. If the value of a is false, the expression will not work as you would expect it to. (Can you tell I was bitten by this?  More than once?)
 
    Example 4.18. When the and-or Trick Fails
    >>> a = ""
 >>> b = "second"
 >>> 1 and a or b         1
@@ -2352,12 +1875,12 @@ the pop method of a list) and user-defined (like the buildCon
 
 1 
 
-Since a is an empty string, which Python considers false in a boolean context, 1 and '' evalutes to '', and then '' or 'second' evalutes to 'second'.  Oops!  That's not what you wanted.
+Since a is an empty string, which Python considers false in a boolean context, 1 and '' evalutes to '', and then '' or 'second' evalutes to 'second'. Oops!  That's not what you wanted.
 
 
 
 
    The and-or trick, bool and a or b, will not work like the C expression bool ? a : b when a is false in a boolean context.
-
    The real trick behind the and-or trick, then, is to make sure that the value of a is never false.  One common way of doing this is to turn a into [a] and b into [b], then taking the first element of the returned list, which will be either a or b.
+
    The real trick behind the and-or trick, then, is to make sure that the value of a is never false. One common way of doing this is to turn a into [a] and b into [b], then taking the first element of the returned list, which will be either a or b.
 
    Example 4.19. Using the and-or Trick Safely
    >>> a = ""
 >>> b = "second"
 >>> (1 and [a] or [b])[0] 1
@@ -2366,12 +1889,12 @@ the pop method of a list) and user-defined (like the buildCon
 
 1 
 
-Since [a] is a non-empty list, it is never false.  Even if a is 0 or '' or some other false value, the list [a] is true because it has one element.
+Since [a] is a non-empty list, it is never false. Even if a is 0 or '' or some other false value, the list [a] is true because it has one element.
 
 
 
-
    By now, this trick may seem like more trouble than it's worth.  You could, after all, accomplish the same thing with an if statement, so why go through all this fuss?  Well, in many cases, you are choosing between two constant values, so you can
-   use the simpler syntax and not worry, because you know that the a value will always be true.  And even if you need to use the more complicated safe form, there are good reasons to do so.
+
    By now, this trick may seem like more trouble than it's worth. You could, after all, accomplish the same thing with an if statement, so why go through all this fuss?  Well, in many cases, you are choosing between two constant values, so you can
+   use the simpler syntax and not worry, because you know that the a value will always be true. And even if you need to use the more complicated safe form, there are good reasons to do so.
    For example, there are some cases in Python where if statements are not allowed, such as in lambda functions.
 
    
 
    Further Reading on the and-or Trick
    
@@ -2380,10 +1903,10 @@ the pop method of a list) and user-defined (like the buildCon
 
 
 
    4.7. Using lambda Functions
    
-
    Python supports an interesting syntax that lets you define one-line mini-functions on the fly.  Borrowed from Lisp, these so-called lambda functions can be used anywhere a function is required.
+
    Python supports an interesting syntax that lets you define one-line mini-functions on the fly. Borrowed from Lisp, these so-called lambda functions can be used anywhere a function is required.
 
    Example 4.20. Introducing lambda Functions
    >>> def f(x):
-...     return x*2
-...     
+...    return x*2
+...    
 >>> f(3)
 6
 >>> g = lambda x: x*2  1
@@ -2395,27 +1918,27 @@ the pop method of a list) and user-defined (like the buildCon
 
 1 
 
-This is a lambda function that accomplishes the same thing as the normal function above it.  Note the abbreviated syntax here: there are no
-            parentheses around the argument list, and the return keyword is missing (it is implied, since the entire function can only be one expression).  Also, the function has no name,
+This is a lambda function that accomplishes the same thing as the normal function above it. Note the abbreviated syntax here: there are no
+            parentheses around the argument list, and the return keyword is missing (it is implied, since the entire function can only be one expression). Also, the function has no name,
             but it can be called through the variable it is assigned to.
 
 
 
 2 
 
-You can use a lambda function without even assigning it to a variable.  This may not be the most useful thing in the world, but it just goes to
+You can use a lambda function without even assigning it to a variable. This may not be the most useful thing in the world, but it just goes to
             show that a lambda is just an in-line function.
 
 
 
-
    To generalize, a lambda function is a function that takes any number of arguments (including optional arguments) and returns the value of a single expression.  lambda functions can not contain commands, and they can not contain more than one expression.  Don't try to squeeze too much into
+
    To generalize, a lambda function is a function that takes any number of arguments (including optional arguments) and returns the value of a single expression. lambda functions can not contain commands, and they can not contain more than one expression. Don't try to squeeze too much into
 a lambda function; if you need something more complex, define a normal function instead and make it as long as you want.
-
@@ -2423,8 +1946,8 @@ a lambda function; if you need something more complex, define a nor
 
    4.7.1. Real-World lambda Functions
    
 
    Here are the lambda functions in apihelper.py:
    -    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    Notice that this uses the simple form of the and-or trick, which is okay, because a lambda function is always true in a boolean context.  (That doesn't mean that a lambda function can't return a false value.  The function is always true; its return value could be anything.)
-
    Also notice that you're using the split function with no arguments.  You've already seen it used with one or two arguments, but without any arguments it splits on whitespace.
+    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    Notice that this uses the simple form of the and-or trick, which is okay, because a lambda function is always true in a boolean context. (That doesn't mean that a lambda function can't return a false value. The function is always true; its return value could be anything.)
+
    Also notice that you're using the split function with no arguments. You've already seen it used with one or two arguments, but without any arguments it splits on whitespace.
 
    Example 4.21. split With No Arguments
    >>> s = "this   is\na\ttest"  1
 >>> print s
 this   is
@@ -2437,52 +1960,52 @@ a	test
 
    
-
-
-
    
 
    
 Note
 
    
 
    lambda functions are a matter of style.  Using them is never required; anywhere you could use them, you could define a separate
-      normal function and use that instead.  I use them in places where I want to encapsulate specific, non-reusable code without
+lambda functions are a matter of style. Using them is never required; anywhere you could use them, you could define a separate
+      normal function and use that instead. I use them in places where I want to encapsulate specific, non-reusable code without
       littering my code with a lot of little one-line functions.
 
 
    
 
    
 1 
 This is a multiline string, defined by escape characters instead of triple quotes.  \n is a carriage return, and \t is a tab character.
+This is a multiline string, defined by escape characters instead of triple quotes. \n is a carriage return, and \t is a tab character.
 
 
    
 
    
 2 
 split without any arguments splits on whitespace.  So three spaces, a carriage return, and a tab character are all the same.
+split without any arguments splits on whitespace. So three spaces, a carriage return, and a tab character are all the same.
 
 
    
 
    
 3 
 You can normalize whitespace by splitting a string with split and then rejoining it with join, using a single space as a delimiter.  This is what the info function does to collapse multi-line docstrings into a single line.
+You can normalize whitespace by splitting a string with split and then rejoining it with join, using a single space as a delimiter. This is what the info function does to collapse multi-line docstrings into a single line.
 
 
    
 
    
 
    So what is the info function actually doing with these lambda functions, splits, and and-or tricks?
 
    -    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    processFunc is now a function, but which function it is depends on the value of the collapse variable.  If collapse is true, processFunc(string) will collapse whitespace; otherwise, processFunc(string) will return its argument unchanged.
-
    To do this in a less robust language, like Visual Basic, you would probably create a function that took a string and a collapse argument and used an if statement to decide whether to collapse the whitespace or not, then returned the appropriate value.  This would be inefficient,
-   because the function would need to handle every possible case.  Every time you called it, it would need to decide whether
-   to collapse whitespace before it could give you what you wanted.  In Python, you can take that decision logic out of the function and define a lambda function that is custom-tailored to give you exactly (and only) what you want.  This is more efficient, more elegant, and
+    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    processFunc is now a function, but which function it is depends on the value of the collapse variable. If collapse is true, processFunc(string) will collapse whitespace; otherwise, processFunc(string) will return its argument unchanged.
+
    To do this in a less robust language, like Visual Basic, you would probably create a function that took a string and a collapse argument and used an if statement to decide whether to collapse the whitespace or not, then returned the appropriate value. This would be inefficient,
+   because the function would need to handle every possible case. Every time you called it, it would need to decide whether
+   to collapse whitespace before it could give you what you wanted. In Python, you can take that decision logic out of the function and define a lambda function that is custom-tailored to give you exactly (and only) what you want. This is more efficient, more elegant, and
    less prone to those nasty oh-I-thought-those-arguments-were-reversed kinds of errors.
 
    
 
    Further Reading on lambda Functions
    
 
 
    4.8. Putting It All Together
    
-
    The last line of code, the only one you haven't deconstructed yet, is the one that does all the work.  But by now the work
-   is easy, because everything you need is already set up just the way you need it.  All the dominoes are in place; it's time
+
    The last line of code, the only one you haven't deconstructed yet, is the one that does all the work. But by now the work
+   is easy, because everything you need is already set up just the way you need it. All the dominoes are in place; it's time
    to knock them down.
 
    
 
    This is the meat of apihelper.py:
         print "\n".join(["%s %s" %
     (method.ljust(spacing),
      processFunc(str(getattr(object, method).__doc__)))
-   for method in methodList])
    Note that this is one command, split over multiple lines, but it doesn't use the line continuation character (\).  Remember when I said that some expressions can be split into multiple lines without using a backslash?  A list comprehension is one of those expressions, since the entire expression is contained in
+   for method in methodList])
    Note that this is one command, split over multiple lines, but it doesn't use the line continuation character (\). Remember when I said that some expressions can be split into multiple lines without using a backslash?  A list comprehension is one of those expressions, since the entire expression is contained in
 square brackets.
-
    Now, let's take it from the end and work backwards.  The 
    -for method in methodList
    shows that this is a list comprehension.  As you know, methodList is a list of all the methods you care about in object.  So you're looping through that list with method.
+
    Now, let's take it from the end and work backwards. The 
    +for method in methodList
    shows that this is a list comprehension. As you know, methodList is a list of all the methods you care about in object. So you're looping through that list with method.
 
    Example 4.22. Getting a docstring Dynamically
    >>> import odbchelper
 >>> object = odbchelper 1
 >>> method = 'buildConnectionString'      2
@@ -2518,7 +2041,7 @@ for method in methodList
    shows that this is a 
 
 
-
    The next piece of the puzzle is the use of str around the docstring.  As you may recall, str is a built-in function that coerces data into a string.  But a docstring is always a string, so why bother with the str function?  The answer is that not every function has a docstring, and if it doesn't, its __doc__ attribute is None.
+
    The next piece of the puzzle is the use of str around the docstring. As you may recall, str is a built-in function that coerces data into a string. But a docstring is always a string, so why bother with the str function?  The answer is that not every function has a docstring, and if it doesn't, its __doc__ attribute is None.
 
    Example 4.23. Why Use str on a docstring?
    >>> >>> def foo(): print 2
 >>> >>> foo()
 2
@@ -2532,7 +2055,7 @@ True
 
 1 
 
-You can easily define a function that has no docstring, so its __doc__ attribute is None.  Confusingly, if you evaluate the __doc__ attribute directly, the Python IDE prints nothing at all, which makes sense if you think about it, but is still unhelpful.
+You can easily define a function that has no docstring, so its __doc__ attribute is None. Confusingly, if you evaluate the __doc__ attribute directly, the Python IDE prints nothing at all, which makes sense if you think about it, but is still unhelpful.
 
 
 
@@ -2553,12 +2076,12 @@ True
 Note
 
 
-In SQL, you must use IS NULL instead of = NULL to compare a null value.  In Python, you can use either == None or is None, but is None is faster.
+In SQL, you must use IS NULL instead of = NULL to compare a null value. In Python, you can use either == None or is None, but is None is faster.
 
 
 
-
    Now that you are guaranteed to have a string, you can pass the string to processFunc, which you have already defined as a function that either does or doesn't collapse whitespace.  Now you see why it was important to use str to convert a None value into a string representation.  processFunc is assuming a string argument and calling its split method, which would crash if you passed it None because None doesn't have a split method.
-
    Stepping back even further, you see that you're using string formatting again to concatenate the return value of processFunc with the return value of method's ljust method.  This is a new string method that you haven't seen before.
+
    Now that you are guaranteed to have a string, you can pass the string to processFunc, which you have already defined as a function that either does or doesn't collapse whitespace. Now you see why it was important to use str to convert a None value into a string representation. processFunc is assuming a string argument and calling its split method, which would crash if you passed it None because None doesn't have a split method.
+
    Stepping back even further, you see that you're using string formatting again to concatenate the return value of processFunc with the return value of method's ljust method. This is a new string method that you haven't seen before.
 
    Example 4.24. Introducing ljust
    >>> s = 'buildConnectionString'
 >>> s.ljust(30) 1
 'buildConnectionString         '
@@ -2568,17 +2091,17 @@ True
 
 1 
 
-ljust pads the string with spaces to the given length.  This is what the info function uses to make two columns of output and line up all the docstrings in the second column.
+ljust pads the string with spaces to the given length. This is what the info function uses to make two columns of output and line up all the docstrings in the second column.
 
 
 
 2 
 
-If the given length is smaller than the length of the string, ljust will simply return the string unchanged.  It never truncates the string.
+If the given length is smaller than the length of the string, ljust will simply return the string unchanged. It never truncates the string.
 
 
 
-
    You're almost finished.  Given the padded method name from the ljust method and the (possibly collapsed) docstring from the call to processFunc, you concatenate the two and get a single string.  Since you're mapping methodList, you end up with a list of strings.  Using the join method of the string "\n", you join this list into a single string, with each element of the list on a separate line, and print the result.
+
    You're almost finished. Given the padded method name from the ljust method and the (possibly collapsed) docstring from the call to processFunc, you concatenate the two and get a single string. Since you're mapping methodList, you end up with a list of strings. Using the join method of the string "\n", you join this list into a single string, with each element of the list on a separate line, and print the result.
 
    Example 4.25. Printing a List
    >>> li = ['a', 'b', 'c']
 >>> print "\n".join(li) 1
 a
@@ -2588,11 +2111,11 @@ c
    
 
 1 
 
-This is also a useful debugging trick when you're working with lists.  And in Python, you're always working with lists.
+This is also a useful debugging trick when you're working with lists. And in Python, you're always working with lists.
 
 
 
-
    That's the last piece of the puzzle.  You should now understand this code.
+
    That's the last piece of the puzzle. You should now understand this code.
 
         print "\n".join(["%s %s" %
     (method.ljust(spacing),
@@ -2637,21 +2160,21 @@ sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1,
 
  • Recognizing the and-or trick and using it safely
 
 
  • Defining lambda functions
-
  • Assigning functions to variables and calling the function by referencing the variable.  I can't emphasize this enough, because this mode of thought is vital
-         to advancing your understanding of Python.  You'll see more complex applications of this concept throughout this book.
+
  • Assigning functions to variables and calling the function by referencing the variable. I can't emphasize this enough, because this mode of thought is vital
+         to advancing your understanding of Python. You'll see more complex applications of this concept throughout this book.
 
 
 
    
 
    Chapter 5. Objects and Object-Orientation
    
 
    This chapter, and pretty much every chapter after this, deals with object-oriented Python programming.
 
    5.1. Diving In
    
-
    Here is a complete, working Python program.  Read the docstrings of the module, the classes, and the functions to get an overview of what this program does and how it works.  As usual, don't
+
    Here is a complete, working Python program. Read the docstrings of the module, the classes, and the functions to get an overview of what this program does and how it works. As usual, don't
    worry about the stuff you don't understand; that's what the rest of the chapter is for.
 
    Example 5.1. fileinfo.py
    
 
    If you have not already done so, you can download this and other examples used in this book.
     """Framework for getting filetype-specific metadata.
 
-Instantiate appropriate class with filename.  Returned object acts like a
+Instantiate appropriate class with filename. Returned object acts like a
 dictionary, with key-value pairs for each piece of metadata.
     import fileinfo
     info = fileinfo.MP3FileInfo("/music/ap/mahadeva.mp3")
@@ -2662,7 +2185,7 @@ Or use listDirectory function to get info on all files in a directory.
         ...
 
 Framework can be extended by adding classes for particular file types, e.g.
-HTMLFileInfo, MPGFileInfo, DOCFileInfo.  Each class is completely responsible for
+HTMLFileInfo, MPGFileInfo, DOCFileInfo. Each class is completely responsible for
 parsing its files appropriately; see MP3FileInfo for example.
 """
 import os
@@ -2730,13 +2253,13 @@ if __name__ == "__main__":
 
 1 
 
-This program's output depends on the files on your hard drive.  To get meaningful output, you'll need to change the directory
+This program's output depends on the files on your hard drive. To get meaningful output, you'll need to change the directory
             path to point to a directory of MP3 files on your own machine.
 
 
 
 
    
-
    This is the output I got on my machine.  Your output will be different, unless, by some startling coincidence, you share my
+
    This is the output I got on my machine. Your output will be different, unless, by some startling coincidence, you share my
    exact taste in music.
    album=
 artist=Ghost in the Machine
 title=A Time Long Forgotten (Concept
@@ -2784,11 +2307,11 @@ genre=255
 name=/music/_singles/spinning.mp3
 year=2000
 comment=http://mp3.com/artists/95/vxp
    5.2. Importing Modules Using from module import
    
-
    Python has two ways of importing modules.  Both are useful, and you should know when to use each.  One way, import module, you've already seen in Section 2.4, “Everything Is an Object”.  The other way accomplishes the same thing, but it has subtle and important differences.
+
    Python has two ways of importing modules. Both are useful, and you should know when to use each. One way, import module, you've already seen in Section 2.4, “Everything Is an Object”. The other way accomplishes the same thing, but it has subtle and important differences.
 
    
 
    Here is the basic from module import syntax:
     from UserDict import UserDict
-
    This is similar to the import module syntax that you know and love, but with an important difference: the attributes and methods of the imported module types are imported directly into the local namespace, so they are available directly, without qualification by module name.  You
+
    This is similar to the import module syntax that you know and love, but with an important difference: the attributes and methods of the imported module types are imported directly into the local namespace, so they are available directly, without qualification by module name. You
 can import individual items or use from module import * to import everything.
@@ -2820,7 +2343,7 @@ NameError: There is no variable named 'FunctionType'
-
@@ -2873,7 +2396,7 @@ NameError: There is no variable named 'FunctionType'
    5.3. Defining Classes
    Python is fully object-oriented: you can define your own classes, inherit from your own or built-in classes, and instantiate the
    classes you've defined.
-
    Defining a class in Python is simple.  As with functions, there is no separate interface definition.  Just define the class and start coding.  A Python class starts with the reserved word class, followed by the class name.  Technically, that's all that's required, since a class doesn't need to inherit from any other
+
    Defining a class in Python is simple. As with functions, there is no separate interface definition. Just define the class and start coding. A Python class starts with the reserved word class, followed by the class name. Technically, that's all that's required, since a class doesn't need to inherit from any other
 class.
 
    Example 5.3. The Simplest Python Class
     class Loaf: 1
@@ -2882,20 +2405,20 @@ class Loaf: 1
 
    
-
-
    
 
    
 Note
 
    
 1 
 The types module contains no methods; it just has attributes for each Python object type.  Note that the attribute, FunctionType, must be qualified by the module name, types.
+The types module contains no methods; it just has attributes for each Python object type. Note that the attribute, FunctionType, must be qualified by the module name, types.
 
 
    
 
    
 
 1 
 The name of this class is Loaf, and it doesn't inherit from any other class.  Class names are usually capitalized, EachWordLikeThis, but this is only a convention, not a requirement.
+The name of this class is Loaf, and it doesn't inherit from any other class. Class names are usually capitalized, EachWordLikeThis, but this is only a convention, not a requirement.
 
 
    
 
    
 2 
 
 This class doesn't define any methods or attributes, but syntactically, there needs to be something in the definition, so
-            you use pass.  This is a Python reserved word that just means “move along, nothing to see here”.  It's a statement that does nothing, and it's a good placeholder when you're stubbing out functions or classes.
+            you use pass. This is a Python reserved word that just means “move along, nothing to see here”. It's a statement that does nothing, and it's a good placeholder when you're stubbing out functions or classes.
 
 
    
 
    
 3 
 You probably guessed this, but everything in a class is indented, just like the code within a function, if statement, for loop, and so forth.  The first thing not indented is not in the class.
+You probably guessed this, but everything in a class is indented, just like the code within a function, if statement, for loop, and so forth. The first thing not indented is not in the class.
 
 
    
 
    
@@ -2909,8 +2432,8 @@ class Loaf: 1
 
 
    Of course, realistically, most classes will be inherited from other classes, and they will define their own class methods
-and attributes.  But as you've just seen, there is nothing that a class absolutely must have, other than a name.  In particular,
-C++ programmers may find it odd that Python classes don't have explicit constructors and destructors.  Python classes do have something similar to a constructor: the __init__ method.
+and attributes. But as you've just seen, there is nothing that a class absolutely must have, other than a name. In particular,
+C++ programmers may find it odd that Python classes don't have explicit constructors and destructors. Python classes do have something similar to a constructor: the __init__ method.
 
    Example 5.4. Defining the FileInfo Class
     from UserDict import UserDict
 
@@ -2919,7 +2442,7 @@ class FileInfo(UserDict): 1 
 
-In Python, the ancestor of a class is simply listed in parentheses immediately after the class name.  So the FileInfo class is inherited from the UserDict class (which was imported from the UserDict module).  UserDict is a class that acts like a dictionary, allowing you to essentially subclass the dictionary datatype and add your own behavior.
+In Python, the ancestor of a class is simply listed in parentheses immediately after the class name. So the FileInfo class is inherited from the UserDict class (which was imported from the UserDict module). UserDict is a class that acts like a dictionary, allowing you to essentially subclass the dictionary datatype and add your own behavior.
              (There are similar classes UserList and UserString which allow you to subclass lists and strings.)  There is a bit of black magic behind this, which you will demystify later
             in this chapter when you explore the UserDict class in more depth.
 
@@ -2930,12 +2453,12 @@ class FileInfo(UserDict): Note
 
 
-In Python, the ancestor of a class is simply listed in parentheses immediately after the class name.  There is no special keyword like
+In Python, the ancestor of a class is simply listed in parentheses immediately after the class name. There is no special keyword like
 extends in Java.
 
 
 
-
    Python supports multiple inheritance.  In the parentheses following the class name, you can list as many ancestor classes as you
+
    Python supports multiple inheritance. In the parentheses following the class name, you can list as many ancestor classes as you
 like, separated by commas.
 
    5.3.1. Initializing and Coding Classes
    
 
    This example shows the initialization of the FileInfo class using the __init__ method.
@@ -2953,15 +2476,15 @@ class FileInfo(UserDict):
 
 2 
 
-__init__ is called immediately after an instance of the class is created.  It would be tempting but incorrect to call this the constructor
-               of the class.  It's tempting, because it looks like a constructor (by convention, __init__ is the first method defined for the class), acts like one (it's the first piece of code executed in a newly created instance
-               of the class), and even sounds like one (“init” certainly suggests a constructor-ish nature).  Incorrect, because the object has already been constructed by the time __init__ is called, and you already have a valid reference to the new instance of the class.  But __init__ is the closest thing you're going to get to a constructor in Python, and it fills much the same role.
+__init__ is called immediately after an instance of the class is created. It would be tempting but incorrect to call this the constructor
+               of the class. It's tempting, because it looks like a constructor (by convention, __init__ is the first method defined for the class), acts like one (it's the first piece of code executed in a newly created instance
+               of the class), and even sounds like one (“init” certainly suggests a constructor-ish nature). Incorrect, because the object has already been constructed by the time __init__ is called, and you already have a valid reference to the new instance of the class. But __init__ is the closest thing you're going to get to a constructor in Python, and it fills much the same role.
 
 
 
 3 
 
-The first argument of every class method, including __init__, is always a reference to the current instance of the class.  By convention, this argument is always named self.  In the __init__ method, self refers to the newly created object; in other class methods, it refers to the instance whose method was called.  Although
+The first argument of every class method, including __init__, is always a reference to the current instance of the class. By convention, this argument is always named self. In the __init__ method, self refers to the newly created object; in other class methods, it refers to the instance whose method was called. Although
                you need to specify self explicitly when defining the method, you do not specify it when calling the method; Python will add it for you automatically.
 
 
@@ -2969,7 +2492,7 @@ class FileInfo(UserDict):
 4 
 
 __init__ methods can take any number of arguments, and just like functions, the arguments can be defined with default values, making
-               them optional to the caller.  In this case, filename has a default value of None, which is the Python null value.
+               them optional to the caller. In this case, filename has a default value of None, which is the Python null value.
 
 
 
@@ -2978,7 +2501,7 @@ class FileInfo(UserDict):
 Note
 
 
-By convention, the first argument of any Python class method (the reference to the current instance) is called self.  This argument fills the role of the reserved word this in C++ or Java, but self is not a reserved word in Python, merely a naming convention.  Nonetheless, please don't call it anything but self; this is a very strong convention.
+By convention, the first argument of any Python class method (the reference to the current instance) is called self. This argument fills the role of the reserved word this in C++ or Java, but self is not a reserved word in Python, merely a naming convention. Nonetheless, please don't call it anything but self; this is a very strong convention.
 
 
 
@@ -3000,7 +2523,7 @@ class FileInfo(UserDict):
 
 2 
 
-I told you that this class acts like a dictionary, and here is the first sign of it.  You're assigning the argument filename as the value of this object's name key.
+I told you that this class acts like a dictionary, and here is the first sign of it. You're assigning the argument filename as the value of this object's name key.
 
 
 
@@ -3011,16 +2534,16 @@ class FileInfo(UserDict):
 
 
 
    5.3.2. Knowing When to Use self and __init__
    
-
    When defining your class methods, you must explicitly list self as the first argument for each method, including __init__.  When you call a method of an ancestor class from within your class, you must include the self argument.  But when you call your class method from outside, you do not specify anything for the self argument; you skip it entirely, and Python automatically adds the instance reference for you.  I am aware that this is confusing at first; it's not really inconsistent,
+
    When defining your class methods, you must explicitly list self as the first argument for each method, including __init__. When you call a method of an ancestor class from within your class, you must include the self argument. But when you call your class method from outside, you do not specify anything for the self argument; you skip it entirely, and Python automatically adds the instance reference for you. I am aware that this is confusing at first; it's not really inconsistent,
    but it may appear inconsistent because it relies on a distinction (between bound and unbound methods) that you don't know
    about yet.
-
    Whew.  I realize that's a lot to absorb, but you'll get the hang of it.  All Python classes work the same way, so once you learn one, you've learned them all.  If you forget everything else, remember this
+
    Whew. I realize that's a lot to absorb, but you'll get the hang of it. All Python classes work the same way, so once you learn one, you've learned them all. If you forget everything else, remember this
    one thing, because I promise it will trip you up:
-
@@ -3038,8 +2561,8 @@ class FileInfo(UserDict):
 
 
    5.4. Instantiating Classes
    
-
    Instantiating classes in Python is straightforward.  To instantiate a class, simply call the class as if it were a function, passing the arguments that the
-__init__ method defines.  The return value will be the newly created object.
+
    Instantiating classes in Python is straightforward. To instantiate a class, simply call the class as if it were a function, passing the arguments that the
+__init__ method defines. The return value will be the newly created object.
 
    Example 5.7. Creating a FileInfo Instance
    >>> import fileinfo
 >>> f = fileinfo.FileInfo("/music/_singles/kairo.mp3") 1
 >>> f.__class__    2
@@ -3052,26 +2575,26 @@ class FileInfo(UserDict):
 
    
-
-
-
-
    
 
    
 Note
 
    
 
    __init__ methods are optional, but when you define one, you must remember to explicitly call the ancestor's __init__ method (if it defines one).  This is more generally true: whenever a descendant wants to extend the behavior of the ancestor,
+__init__ methods are optional, but when you define one, you must remember to explicitly call the ancestor's __init__ method (if it defines one). This is more generally true: whenever a descendant wants to extend the behavior of the ancestor,
          the descendant method must explicitly call the ancestor method at the proper time, with the proper arguments.
 
 
    
 
    
 1 
 You are creating an instance of the FileInfo class (defined in the fileinfo module) and assigning the newly created instance to the variable f.  You are passing one parameter, /music/_singles/kairo.mp3, which will end up as the filename argument in FileInfo's __init__ method.
+You are creating an instance of the FileInfo class (defined in the fileinfo module) and assigning the newly created instance to the variable f. You are passing one parameter, /music/_singles/kairo.mp3, which will end up as the filename argument in FileInfo's __init__ method.
 
 
    
 
    
 2 
 Every class instance has a built-in attribute, __class__, which is the object's class.  (Note that the representation of this includes the physical address of the instance on my
-            machine; your representation will be different.)  Java programmers may be familiar with the Class class, which contains methods like getName and getSuperclass to get metadata information about an object.  In Python, this kind of metadata is available directly on the object itself through attributes like __class__, __name__, and __bases__.
+Every class instance has a built-in attribute, __class__, which is the object's class. (Note that the representation of this includes the physical address of the instance on my
+            machine; your representation will be different.)  Java programmers may be familiar with the Class class, which contains methods like getName and getSuperclass to get metadata information about an object. In Python, this kind of metadata is available directly on the object itself through attributes like __class__, __name__, and __bases__.
 
 
    
 
    
 3 
 You can access the instance's docstring just as with a function or a module.  All instances of a class share the same docstring.
+You can access the instance's docstring just as with a function or a module. All instances of a class share the same docstring.
 
 
    
 
    
 4 
 Remember when the __init__ method assigned its filename argument to self["name"]?  Well, here's the result.  The arguments you pass when you create the class instance get sent right along to the __init__ method (along with the object reference, self, which Python adds for free).
+Remember when the __init__ method assigned its filename argument to self["name"]?  Well, here's the result. The arguments you pass when you create the class instance get sent right along to the __init__ method (along with the object reference, self, which Python adds for free).
 
 
    
 
    
@@ -3080,23 +2603,23 @@ class FileInfo(UserDict):
 Note
 
 
-In Python, simply call a class as if it were a function to create a new instance of the class.  There is no explicit new operator like C++ or Java.
+In Python, simply call a class as if it were a function to create a new instance of the class. There is no explicit new operator like C++ or Java.
 
 
 
 
    5.4.1. Garbage Collection
    
-
    If creating new instances is easy, destroying them is even easier.  In general, there is no need to explicitly free instances,
-   because they are freed automatically when the variables assigned to them go out of scope.  Memory leaks are rare in Python.
+
    If creating new instances is easy, destroying them is even easier. In general, there is no need to explicitly free instances,
+   because they are freed automatically when the variables assigned to them go out of scope. Memory leaks are rare in Python.
 
    Example 5.8. Trying to Implement a Memory Leak
    >>> def leakmem():
-...     f = fileinfo.FileInfo('/music/_singles/kairo.mp3') 1
-...     
+...    f = fileinfo.FileInfo('/music/_singles/kairo.mp3') 1
+...    
 >>> for i in range(100):
-...     leakmem()      2
    
+...    leakmem()      2
    
 
-
@@ -3106,12 +2629,12 @@ class FileInfo(UserDict):
 
    
 
    
 1 
 Every time the leakmem function is called, you are creating an instance of FileInfo and assigning it to the variable f, which is a local variable within the function.  Then the function ends without ever freeing f, so you would expect a memory leak, but you would be wrong.  When the function ends, the local variable f goes out of scope.  At this point, there are no longer any references to the newly created instance of FileInfo (since you never assigned it to anything other than f), so Python destroys the instance for us.
+Every time the leakmem function is called, you are creating an instance of FileInfo and assigning it to the variable f, which is a local variable within the function. Then the function ends without ever freeing f, so you would expect a memory leak, but you would be wrong. When the function ends, the local variable f goes out of scope. At this point, there are no longer any references to the newly created instance of FileInfo (since you never assigned it to anything other than f), so Python destroys the instance for us.
 
 
    
 
    
 
    
 
    
-
    The technical term for this form of garbage collection is “reference counting”.  Python keeps a list of references to every instance created.  In the above example, there was only one reference to the FileInfo instance: the local variable f.  When the function ends, the variable f goes out of scope, so the reference count drops to 0, and Python destroys the instance automatically.
-
    In previous versions of Python, there were situations where reference counting failed, and Python couldn't clean up after you.  If you created two instances that referenced each other (for instance, a doubly-linked list,
+
    The technical term for this form of garbage collection is “reference counting”. Python keeps a list of references to every instance created. In the above example, there was only one reference to the FileInfo instance: the local variable f. When the function ends, the variable f goes out of scope, so the reference count drops to 0, and Python destroys the instance automatically.
+
    In previous versions of Python, there were situations where reference counting failed, and Python couldn't clean up after you. If you created two instances that referenced each other (for instance, a doubly-linked list,
    where each node has a pointer to the previous and next node in the list), neither instance would ever be destroyed automatically
-   because Python (correctly) believed that there is always a reference to each instance.  Python 2.0 has an additional form of garbage collection called “mark-and-sweep” which is smart enough to notice this virtual gridlock and clean up circular references correctly.
+   because Python (correctly) believed that there is always a reference to each instance. Python 2.0 has an additional form of garbage collection called “mark-and-sweep” which is smart enough to notice this virtual gridlock and clean up circular references correctly.
 
    As a former philosophy major, it disturbs me to think that things disappear when no one is looking at them, but that's exactly
-   what happens in Python.  In general, you can simply forget about memory management and let Python clean up after you.
+   what happens in Python. In general, you can simply forget about memory management and let Python clean up after you.
 
    
 
    Further Reading on Garbage Collection
    
 
      
@@ -3121,7 +2644,7 @@ class FileInfo(UserDict):
 
 
    
 
    5.5. Exploring UserDict: A Wrapper Class
    
-
    As you've seen, FileInfo is a class that acts like a dictionary.  To explore this further, let's look at the UserDict class in the UserDict module, which is the ancestor of the FileInfo class.  This is nothing special; the class is written in Python and stored in a .py file, just like any other Python code.  In particular, it's stored in the lib directory in your Python installation.
+
    As you've seen, FileInfo is a class that acts like a dictionary. To explore this further, let's look at the UserDict class in the UserDict module, which is the ancestor of the FileInfo class. This is nothing special; the class is written in Python and stored in a .py file, just like any other Python code. In particular, it's stored in the lib directory in your Python installation.
    
@@ -3147,31 +2670,31 @@ class UserDict:              2
-
-
-
-
    
 
    
 Tip
 
     
 
    This is the __init__ method that you overrode in the FileInfo class.  Note that the argument list in this ancestor class is different than the descendant.  That's okay; each subclass can have
-            its own set of arguments, as long as it calls the ancestor with the correct arguments.  Here the ancestor class has a way
+This is the __init__ method that you overrode in the FileInfo class. Note that the argument list in this ancestor class is different than the descendant. That's okay; each subclass can have
+            its own set of arguments, as long as it calls the ancestor with the correct arguments. Here the ancestor class has a way
             to define initial values (by passing a dictionary in the dict argument) which the FileInfo does not use.
 
 
    
 
    
 3 
 Python supports data attributes (called “instance variables” in Java and Powerbuilder, and “member variables” in C++).  Data attributes are pieces of data held by a specific instance of a class.  In this case, each instance of UserDict will have a data attribute data.  To reference this attribute from code outside the class, you qualify it with the instance name, instance.data, in the same way that you qualify a function with its module name.  To reference a data attribute from within the class,
-            you use self as the qualifier.  By convention, all data attributes are initialized to reasonable values in the __init__ method.  However, this is not required, since data attributes, like local variables, spring into existence when they are first assigned a value.
+Python supports data attributes (called “instance variables” in Java and Powerbuilder, and “member variables” in C++). Data attributes are pieces of data held by a specific instance of a class. In this case, each instance of UserDict will have a data attribute data. To reference this attribute from code outside the class, you qualify it with the instance name, instance.data, in the same way that you qualify a function with its module name. To reference a data attribute from within the class,
+            you use self as the qualifier. By convention, all data attributes are initialized to reasonable values in the __init__ method. However, this is not required, since data attributes, like local variables, spring into existence when they are first assigned a value.
 
 
    
 
    
 4 
 The update method is a dictionary duplicator: it copies all the keys and values from one dictionary to another.  This does not clear the target dictionary first; if the target dictionary already has some keys, the ones from the source dictionary will
-            be overwritten, but others will be left untouched.  Think of update as a merge function, not a copy function.
+The update method is a dictionary duplicator: it copies all the keys and values from one dictionary to another. This does not clear the target dictionary first; if the target dictionary already has some keys, the ones from the source dictionary will
+            be overwritten, but others will be left untouched. Think of update as a merge function, not a copy function.
 
 
    
 
    
 5 
 This is a syntax you may not have seen before (I haven't used it in the examples in this book).  It's an if statement, but instead of having an indented block starting on the next line, there is just a single statement on the same
-            line, after the colon.  This is perfectly legal syntax, which is just a shortcut you can use when you have only one statement
-            in a block.  (It's like specifying a single statement without braces in C++.)  You can use this syntax, or you can have indented code on subsequent lines, but you can't do both for the same block.
+This is a syntax you may not have seen before (I haven't used it in the examples in this book). It's an if statement, but instead of having an indented block starting on the next line, there is just a single statement on the same
+            line, after the colon. This is perfectly legal syntax, which is just a shortcut you can use when you have only one statement
+            in a block. (It's like specifying a single statement without braces in C++.)  You can use this syntax, or you can have indented code on subsequent lines, but you can't do both for the same block.
 
 
    
 
    
@@ -3182,8 +2705,8 @@ class UserDict:              Java and Powerbuilder support function overloading by argument list, i.e. one class can have multiple methods with the same name but a different number of arguments, or arguments of different types.
        Other languages (most notably PL/SQL) even support function overloading by argument name; i.e. one class can have multiple methods with the same name and the same number of arguments of the same type but different argument
-      names.  Python supports neither of these; it has no form of function overloading whatsoever.  Methods are defined solely by their name,
-      and there can be only one method per class with a given name.  So if a descendant class has an __init__ method, it always overrides the ancestor __init__ method, even if the descendant defines it with a different argument list.  And the same rule applies to any other method.
+      names. Python supports neither of these; it has no form of function overloading whatsoever. Methods are defined solely by their name,
+      and there can be only one method per class with a given name. So if a descendant class has an __init__ method, it always overrides the ancestor __init__ method, even if the descendant defines it with a different argument list. And the same rule applies to any other method.
 
 
 
@@ -3202,7 +2725,7 @@ class UserDict:              Caution
-
    
 
 
    Always assign an initial value to all of an instance's data attributes in the __init__ method.  It will save you hours of debugging later, tracking down AttributeError exceptions because you're referencing uninitialized (and therefore non-existent) attributes.
+Always assign an initial value to all of an instance's data attributes in the __init__ method. It will save you hours of debugging later, tracking down AttributeError exceptions because you're referencing uninitialized (and therefore non-existent) attributes.
 
 
    
 
    
@@ -3221,8 +2744,8 @@ class UserDict:              1 
 
-clear is a normal class method; it is publicly available to be called by anyone at any time.  Notice that clear, like all class methods, has self as its first argument.  (Remember that you don't include self when you call the method; it's something that Python adds for you.)  Also note the basic technique of this wrapper class: store a real dictionary (data) as a data attribute, define all the methods that a real dictionary has, and have each class method redirect to the corresponding
-            method on the real dictionary.  (In case you'd forgotten, a dictionary's clear method deletes all of its keys and their associated values.)
+clear is a normal class method; it is publicly available to be called by anyone at any time. Notice that clear, like all class methods, has self as its first argument. (Remember that you don't include self when you call the method; it's something that Python adds for you.)  Also note the basic technique of this wrapper class: store a real dictionary (data) as a data attribute, define all the methods that a real dictionary has, and have each class method redirect to the corresponding
+            method on the real dictionary. (In case you'd forgotten, a dictionary's clear method deletes all of its keys and their associated values.)
 
 
 
@@ -3235,14 +2758,14 @@ class UserDict:              3 
 
-You use the __class__ attribute to see if self is a UserDict; if so, you're golden, because you know how to copy a UserDict: just create a new UserDict and give it the real dictionary that you've squirreled away in self.data.  Then you immediately return the new UserDict you don't even get to the import copy on the next line.
+You use the __class__ attribute to see if self is a UserDict; if so, you're golden, because you know how to copy a UserDict: just create a new UserDict and give it the real dictionary that you've squirreled away in self.data. Then you immediately return the new UserDict you don't even get to the import copy on the next line.
 
 
 
 4 
 
-If self.__class__ is not UserDict, then self must be some subclass of UserDict (like maybe FileInfo), in which case life gets trickier.  UserDict doesn't know how to make an exact copy of one of its descendants; there could, for instance, be other data attributes defined
-            in the subclass, so you would need to iterate through them and make sure to copy all of them.  Luckily, Python comes with a module to do exactly this, and it's called copy.  I won't go into the details here (though it's a wicked cool module, if you're ever inclined to dive into it on your own).
+If self.__class__ is not UserDict, then self must be some subclass of UserDict (like maybe FileInfo), in which case life gets trickier. UserDict doesn't know how to make an exact copy of one of its descendants; there could, for instance, be other data attributes defined
+            in the subclass, so you would need to iterate through them and make sure to copy all of them. Luckily, Python comes with a module to do exactly this, and it's called copy. I won't go into the details here (though it's a wicked cool module, if you're ever inclined to dive into it on your own).
              Suffice it to say that copy can copy arbitrary Python objects, and that's how you're using it here.
 
 
@@ -3258,12 +2781,12 @@ class UserDict:              Note
 
 
-In versions of Python prior to 2.2, you could not directly subclass built-in datatypes like strings, lists, and dictionaries.  To compensate for
-      this, Python comes with wrapper classes that mimic the behavior of these built-in datatypes: UserString, UserList, and UserDict.  Using a combination of normal and special methods, the UserDict class does an excellent imitation of a dictionary.  In Python 2.2 and later, you can inherit classes directly from built-in datatypes like dict.  An example of this is given in the examples that come with this book, in fileinfo_fromdict.py.
+In versions of Python prior to 2.2, you could not directly subclass built-in datatypes like strings, lists, and dictionaries. To compensate for
+      this, Python comes with wrapper classes that mimic the behavior of these built-in datatypes: UserString, UserList, and UserDict. Using a combination of normal and special methods, the UserDict class does an excellent imitation of a dictionary. In Python 2.2 and later, you can inherit classes directly from built-in datatypes like dict. An example of this is given in the examples that come with this book, in fileinfo_fromdict.py.
 
 
 
-
    In Python, you can inherit directly from the dict built-in datatype, as shown in this example.  There are three differences here compared to the UserDict version.
+
    In Python, you can inherit directly from the dict built-in datatype, as shown in this example. There are three differences here compared to the UserDict version.
 
    Example 5.11. Inheriting Directly from Built-In Datatype dict
     class FileInfo(dict):1
     "store file metadata"
@@ -3274,13 +2797,13 @@ class FileInfo(dict):
 1 
 
-The first difference is that you don't need to import the UserDict module, since dict is a built-in datatype and is always available.  The second is that you are inheriting from dict directly, instead of from UserDict.UserDict.
+The first difference is that you don't need to import the UserDict module, since dict is a built-in datatype and is always available. The second is that you are inheriting from dict directly, instead of from UserDict.UserDict.
 
 
 
 2 
 
-The third difference is subtle but important.  Because of the way UserDict works internally, it requires you to manually call its __init__ method to properly initialize its internal data structures.  dict does not work like this; it is not a wrapper, and it requires no explicit initialization.
+The third difference is subtle but important. Because of the way UserDict works internally, it requires you to manually call its __init__ method to properly initialize its internal data structures. dict does not work like this; it is not a wrapper, and it requires no explicit initialization.
 
 
 
@@ -3291,10 +2814,10 @@ class FileInfo(dict):
 
    5.6. Special Class Methods
    
-
    In addition to normal class methods, there are a number of special methods that Python classes can define.  Instead of being called directly by your code (like normal methods), special methods are called for
+
    In addition to normal class methods, there are a number of special methods that Python classes can define. Instead of being called directly by your code (like normal methods), special methods are called for
    you by Python in particular circumstances or when specific syntax is used.
-
    As you saw in the previous section, normal methods go a long way towards wrapping a dictionary in a class.  But normal methods alone are not enough, because
-there are a lot of things you can do with dictionaries besides call methods on them.  For starters, you can get and set items with a syntax that doesn't include explicitly invoking methods.  This is where special class methods come in: they
+
    As you saw in the previous section, normal methods go a long way towards wrapping a dictionary in a class. But normal methods alone are not enough, because
+there are a lot of things you can do with dictionaries besides call methods on them. For starters, you can get and set items with a syntax that doesn't include explicitly invoking methods. This is where special class methods come in: they
 provide a way to map non-method-calling syntax into method calls.
 
    5.6.1. Getting and Setting Items
    
 
    Example 5.12. The __getitem__ Special Method
    @@ -3309,14 +2832,14 @@ provide a way to map non-method-calling syntax into method calls.
 
 1 
 
-The __getitem__ special method looks simple enough.  Like the normal methods clear, keys, and values, it just redirects to the dictionary to return its value.  But how does it get called?  Well, you can call __getitem__ directly, but in practice you wouldn't actually do that; I'm just doing it here to show you how it works.  The right way
+The __getitem__ special method looks simple enough. Like the normal methods clear, keys, and values, it just redirects to the dictionary to return its value. But how does it get called?  Well, you can call __getitem__ directly, but in practice you wouldn't actually do that; I'm just doing it here to show you how it works. The right way
                to use __getitem__ is to get Python to call it for you.
 
 
 
 2 
 
-This looks just like the syntax you would use to get a dictionary value, and in fact it returns the value you would expect.  But here's the missing link: under the covers, Python has converted this syntax to the method call f.__getitem__("name").  That's why __getitem__ is a special class method; not only can you call it yourself, you can get Python to call it for you by using the right syntax.
+This looks just like the syntax you would use to get a dictionary value, and in fact it returns the value you would expect. But here's the missing link: under the covers, Python has converted this syntax to the method call f.__getitem__("name"). That's why __getitem__ is a special class method; not only can you call it yourself, you can get Python to call it for you by using the right syntax.
 
 
 
@@ -3334,22 +2857,22 @@ provide a way to map non-method-calling syntax into method calls.
 
 1 
 
-Like the __getitem__ method, __setitem__ simply redirects to the real dictionary self.data to do its work.  And like __getitem__, you wouldn't ordinarily call it directly like this; Python calls __setitem__ for you when you use the right syntax.
+Like the __getitem__ method, __setitem__ simply redirects to the real dictionary self.data to do its work. And like __getitem__, you wouldn't ordinarily call it directly like this; Python calls __setitem__ for you when you use the right syntax.
 
 
 
 2 
 
-This looks like regular dictionary syntax, except of course that f is really a class that's trying very hard to masquerade as a dictionary, and __setitem__ is an essential part of that masquerade.  This line of code actually calls f.__setitem__("genre", 32) under the covers.
+This looks like regular dictionary syntax, except of course that f is really a class that's trying very hard to masquerade as a dictionary, and __setitem__ is an essential part of that masquerade. This line of code actually calls f.__setitem__("genre", 32) under the covers.
 
 
 
-
    __setitem__ is a special class method because it gets called for you, but it's still a class method.  Just as easily as the __setitem__ method was defined in UserDict, you can redefine it in the descendant class to override the ancestor method.  This allows you to define classes that act
+
    __setitem__ is a special class method because it gets called for you, but it's still a class method. Just as easily as the __setitem__ method was defined in UserDict, you can redefine it in the descendant class to override the ancestor method. This allows you to define classes that act
    like dictionaries in some ways but define their own behavior above and beyond the built-in dictionary.
-
    This concept is the basis of the entire framework you're studying in this chapter.  Each file type can have a handler class
-   that knows how to get metadata from a particular type of file.  Once some attributes (like the file's name and location) are
-   known, the handler class knows how to derive other attributes automatically.  This is done by overriding the __setitem__ method, checking for particular keys, and adding additional processing when they are found.
-
    For example, MP3FileInfo is a descendant of FileInfo.  When an MP3FileInfo's name is set, it doesn't just set the name key (like the ancestor FileInfo does); it also looks in the file itself for MP3 tags and populates a whole set of keys.  The next example shows how this works.
+
    This concept is the basis of the entire framework you're studying in this chapter. Each file type can have a handler class
+   that knows how to get metadata from a particular type of file. Once some attributes (like the file's name and location) are
+   known, the handler class knows how to derive other attributes automatically. This is done by overriding the __setitem__ method, checking for particular keys, and adding additional processing when they are found.
+
    For example, MP3FileInfo is a descendant of FileInfo. When an MP3FileInfo's name is set, it doesn't just set the name key (like the ancestor FileInfo does); it also looks in the file itself for MP3 tags and populates a whole set of keys. The next example shows how this works.
 
    Example 5.14. Overriding __setitem__ in MP3FileInfo
         def __setitem__(self, key, item):         1
         if key == "name" and item:            2
@@ -3359,7 +2882,7 @@ provide a way to map non-method-calling syntax into method calls.
 
 1 
 
-Notice that this __setitem__ method is defined exactly the same way as the ancestor method.  This is important, since Python will be calling the method for you, and it expects it to be defined with a certain number of arguments.  (Technically speaking,
+Notice that this __setitem__ method is defined exactly the same way as the ancestor method. This is important, since Python will be calling the method for you, and it expects it to be defined with a certain number of arguments. (Technically speaking,
                the names of the arguments don't matter; only the number of arguments is important.)
 
 
@@ -3372,13 +2895,13 @@ provide a way to map non-method-calling syntax into method calls.
 
 3 
 
-The extra processing you do for names is encapsulated in the __parse method.  This is another class method defined in MP3FileInfo, and when you call it, you qualify it with self.  Just calling __parse would look for a normal function defined outside the class, which is not what you want.  Calling self.__parse will look for a class method defined within the class.  This isn't anything new; you reference data attributes the same way.
+The extra processing you do for names is encapsulated in the __parse method. This is another class method defined in MP3FileInfo, and when you call it, you qualify it with self. Just calling __parse would look for a normal function defined outside the class, which is not what you want. Calling self.__parse will look for a class method defined within the class. This isn't anything new; you reference data attributes the same way.
 
 
 
 4 
 
-After doing this extra processing, you want to call the ancestor method.  Remember that this is never done for you in Python; you must do it manually.  Note that you're calling the immediate ancestor, FileInfo, even though it doesn't have a __setitem__ method.  That's okay, because Python will walk up the ancestor tree until it finds a class with the method you're calling, so this line of code will eventually
+After doing this extra processing, you want to call the ancestor method. Remember that this is never done for you in Python; you must do it manually. Note that you're calling the immediate ancestor, FileInfo, even though it doesn't have a __setitem__ method. That's okay, because Python will walk up the ancestor tree until it finds a class with the method you're calling, so this line of code will eventually
                find and call the __setitem__ defined in UserDict.
 
 
@@ -3388,7 +2911,7 @@ provide a way to map non-method-calling syntax into method calls.
 Note
 
 
-When accessing data attributes within a class, you need to qualify the attribute name: self.attribute.  When calling other methods within a class, you need to qualify the method name: self.method.
+When accessing data attributes within a class, you need to qualify the attribute name: self.attribute. When calling other methods within a class, you need to qualify the method name: self.method.
 
 
 
@@ -3410,14 +2933,14 @@ provide a way to map non-method-calling syntax into method calls.
 
 1 
 
-First, you create an instance of MP3FileInfo, without passing it a filename.  (You can get away with this because the filename argument of the __init__ method is optional.)  Since MP3FileInfo has no __init__ method of its own, Python walks up the ancestor tree and finds the __init__ method of FileInfo.  This __init__ method manually calls the __init__ method of UserDict and then sets the name key to filename, which is None, since you didn't pass a filename.  Thus, mp3file initially looks like a dictionary with one key, name, whose value is None.
+First, you create an instance of MP3FileInfo, without passing it a filename. (You can get away with this because the filename argument of the __init__ method is optional.)  Since MP3FileInfo has no __init__ method of its own, Python walks up the ancestor tree and finds the __init__ method of FileInfo. This __init__ method manually calls the __init__ method of UserDict and then sets the name key to filename, which is None, since you didn't pass a filename. Thus, mp3file initially looks like a dictionary with one key, name, whose value is None.
                
 
 
 
 2 
 
-Now the real fun begins.  Setting the name key of mp3file triggers the __setitem__ method on MP3FileInfo (not UserDict), which notices that you're setting the name key with a real value and calls self.__parse.  Although you haven't traced through the __parse method yet, you can see from the output that it sets several other keys: album, artist, genre, title, year, and comment.
+Now the real fun begins. Setting the name key of mp3file triggers the __setitem__ method on MP3FileInfo (not UserDict), which notices that you're setting the name key with a real value and calls self.__parse. Although you haven't traced through the __parse method yet, you can see from the output that it sets several other keys: album, artist, genre, title, year, and comment.
                
 
 
@@ -3430,7 +2953,7 @@ provide a way to map non-method-calling syntax into method calls.
 
 
 
    5.7. Advanced Special Class Methods
    
-
    Python has more special methods than just __getitem__ and __setitem__.  Some of them let you emulate functionality that you may not even know about.
+
    Python has more special methods than just __getitem__ and __setitem__. Some of them let you emulate functionality that you may not even know about.
 
    This example shows some of the other special methods in UserDict.
 
    Example 5.16. More Special Methods in UserDict
         def __repr__(self): return repr(self.data)     1
@@ -3445,14 +2968,14 @@ provide a way to map non-method-calling syntax into method calls.
 
 1 
 
-__repr__ is a special method that is called when you call repr(instance).  The repr function is a built-in function that returns a string representation of an object.  It works on any object, not just class
-            instances.  You're already intimately familiar with repr and you don't even know it.  In the interactive window, when you type just a variable name and press the ENTER key, Python uses repr to display the variable's value.  Go create a dictionary d with some data and then print repr(d) to see for yourself.
+__repr__ is a special method that is called when you call repr(instance). The repr function is a built-in function that returns a string representation of an object. It works on any object, not just class
+            instances. You're already intimately familiar with repr and you don't even know it. In the interactive window, when you type just a variable name and press the ENTER key, Python uses repr to display the variable's value. Go create a dictionary d with some data and then print repr(d) to see for yourself.
 
 
 
 2 
 
-__cmp__ is called when you compare class instances.  In general, you can compare any two Python objects, not just class instances, by using ==.  There are rules that define when built-in datatypes are considered equal; for instance, dictionaries are equal when they
+__cmp__ is called when you compare class instances. In general, you can compare any two Python objects, not just class instances, by using ==. There are rules that define when built-in datatypes are considered equal; for instance, dictionaries are equal when they
             have all the same keys and values, and strings are equal when they are the same length and contain the same sequence of characters.
              For class instances, you can define the __cmp__ method and code the comparison logic yourself, and then you can use == to compare instances of your class and Python will call your __cmp__ special method for you.
 
@@ -3460,14 +2983,14 @@ provide a way to map non-method-calling syntax into method calls.
 
 3 
 
-__len__ is called when you call len(instance).  The len function is a built-in function that returns the length of an object.  It works on any object that could reasonably be thought
-            of as having a length.  The len of a string is its number of characters; the len of a dictionary is its number of keys; the len of a list or tuple is its number of elements.  For class instances, define the __len__ method and code the length calculation yourself, and then call len(instance) and Python will call your __len__ special method for you.
+__len__ is called when you call len(instance). The len function is a built-in function that returns the length of an object. It works on any object that could reasonably be thought
+            of as having a length. The len of a string is its number of characters; the len of a dictionary is its number of keys; the len of a list or tuple is its number of elements. For class instances, define the __len__ method and code the length calculation yourself, and then call len(instance) and Python will call your __len__ special method for you.
 
 
 
 4 
 
-__delitem__ is called when you call del instance[key], which you may remember as the way to delete individual items from a dictionary.  When you use del on a class instance, Python calls the __delitem__ special method for you.
+__delitem__ is called when you call del instance[key], which you may remember as the way to delete individual items from a dictionary. When you use del on a class instance, Python calls the __delitem__ special method for you.
 
 
 
@@ -3476,13 +2999,13 @@ provide a way to map non-method-calling syntax into method calls.
 Note
 
 
-In Java, you determine whether two string variables reference the same physical memory location by using str1 == str2.  This is called object identity, and it is written in Python as str1 is str2.  To compare string values in Java, you would use str1.equals(str2); in Python, you would use str1 == str2.  Java programmers who have been taught to believe that the world is a better place because == in Java compares by identity instead of by value may have a difficult time adjusting to Python's lack of such “gotchas”.
+In Java, you determine whether two string variables reference the same physical memory location by using str1 == str2. This is called object identity, and it is written in Python as str1 is str2. To compare string values in Java, you would use str1.equals(str2); in Python, you would use str1 == str2. Java programmers who have been taught to believe that the world is a better place because == in Java compares by identity instead of by value may have a difficult time adjusting to Python's lack of such “gotchas”.
 
 
 
-
    At this point, you may be thinking, “All this work just to do something in a class that I can do with a built-in datatype.”  And it's true that life would be easier (and the entire UserDict class would be unnecessary) if you could inherit from built-in datatypes like a dictionary.  But even if you could, special
+
    At this point, you may be thinking, “All this work just to do something in a class that I can do with a built-in datatype.”  And it's true that life would be easier (and the entire UserDict class would be unnecessary) if you could inherit from built-in datatypes like a dictionary. But even if you could, special
 methods would still be useful, because they can be used in any class, not just wrapper classes like UserDict.
-
    Special methods mean that any class can store key/value pairs like a dictionary, just by defining the __setitem__ method.  Any class can act like a sequence, just by defining the __getitem__ method.  Any class that defines the __cmp__ method can be compared with ==.  And if your class represents something that has a length, don't define a GetLength method; define the __len__ method and use len(instance).
+
    Special methods mean that any class can store key/value pairs like a dictionary, just by defining the __setitem__ method. Any class can act like a sequence, just by defining the __getitem__ method. Any class that defines the __cmp__ method can be compared with ==. And if your class represents something that has a length, don't define a GetLength method; define the __len__ method and use len(instance).
    
@@ -3491,9 +3014,9 @@ methods would still be useful, because they can be used in any class, not just w
 
    
 
    
 Note
 
    
 
 
    
-
    Python has a lot of other special methods.  There's a whole set of them that let classes act like numbers, allowing you to add,
-subtract, and do other arithmetic operations on class instances.  (The canonical example of this is a class that represents
-complex numbers, numbers with both real and imaginary components.)  The __call__ method lets a class act like a function, allowing you to call a class instance directly.  And there are other special methods
+
    Python has a lot of other special methods. There's a whole set of them that let classes act like numbers, allowing you to add,
+subtract, and do other arithmetic operations on class instances. (The canonical example of this is a class that represents
+complex numbers, numbers with both real and imaginary components.)  The __call__ method lets a class act like a function, allowing you to call a class instance directly. And there are other special methods
 that allow classes to have read-only and write-only data attributes; you'll talk more about those in later chapters.
 
    
 
    Further Reading on Special Class Methods
    
@@ -3502,7 +3025,7 @@ that allow classes to have read-only and write-only data attributes; you'll talk
 
 
 
    5.8. Introducing Class Attributes
    
-
    You already know about data attributes, which are variables owned by a specific instance of a class.  Python also supports class attributes, which are variables owned by the class itself.
+
    You already know about data attributes, which are variables owned by a specific instance of a class. Python also supports class attributes, which are variables owned by the class itself.
 
    Example 5.17. Introducing Class Attributes
     class MP3FileInfo(FileInfo):
     "store ID3v1.0 MP3 tags"
@@ -3539,7 +3062,7 @@ class MP3FileInfo(FileInfo):
 
 2 
 
-tagDataMap is a class attribute: literally, an attribute of the class.  It is available before creating any instances of the class.
+tagDataMap is a class attribute: literally, an attribute of the class. It is available before creating any instances of the class.
 
 
 
@@ -3553,24 +3076,24 @@ class MP3FileInfo(FileInfo):
 Note
 
 
-In Java, both static variables (called class attributes in Python) and instance variables (called data attributes in Python) are defined immediately after the class definition (one with the static keyword, one without).  In Python, only class attributes can be defined here; data attributes are defined in the __init__ method.
+In Java, both static variables (called class attributes in Python) and instance variables (called data attributes in Python) are defined immediately after the class definition (one with the static keyword, one without). In Python, only class attributes can be defined here; data attributes are defined in the __init__ method.
 
 
 
-
    Class attributes can be used as class-level constants (which is how you use them in MP3FileInfo), but they are not really constants.  You can also change them.
+
    Class attributes can be used as class-level constants (which is how you use them in MP3FileInfo), but they are not really constants. You can also change them.
    
-
    
 
    
 Note
 
    
 
    There are no constants in Python.  Everything can be changed if you try hard enough.  This fits with one of the core principles of Python: bad behavior should be discouraged but not banned.  If you really want to change the value of None, you can do it, but don't come running to me when your code is impossible to debug.
+There are no constants in Python. Everything can be changed if you try hard enough. This fits with one of the core principles of Python: bad behavior should be discouraged but not banned. If you really want to change the value of None, you can do it, but don't come running to me when your code is impossible to debug.
 
 
    
 
    
 
    Example 5.18. Modifying Class Attributes
    >>> class counter:
-...     count = 0   1
-...     def __init__(self):
-...         self.__class__.count += 1 2
-...     
+...    count = 0   1
+...    def __init__(self):
+...        self.__class__.count += 1 2
+...    
 >>> counter
 <class __main__.counter at 010EAECC>
 >>> counter.count   3
@@ -3597,7 +3120,7 @@ class MP3FileInfo(FileInfo):
 
 2 
 
-__class__ is a built-in attribute of every class instance (of every class).  It is a reference to the class that self is an instance of (in this case, the counter class).
+__class__ is a built-in attribute of every class instance (of every class). It is a reference to the class that self is an instance of (in this case, the counter class).
 
 
 
@@ -3610,13 +3133,13 @@ class MP3FileInfo(FileInfo):
 
 4 
 
-Creating an instance of the class calls the __init__ method, which increments the class attribute count by 1.  This affects the class itself, not just the newly created instance.
+Creating an instance of the class calls the __init__ method, which increments the class attribute count by 1. This affects the class itself, not just the newly created instance.
 
 
 
 5 
 
-Creating a second instance will increment the class attribute count again.  Notice how the class attribute is shared by the class and all instances of the class.
+Creating a second instance will increment the class attribute count again. Notice how the class attribute is shared by the class and all instances of the class.
 
 
 
@@ -3630,15 +3153,15 @@ class MP3FileInfo(FileInfo):
 
 
    Unlike in most languages, whether a Python function, method, or attribute is private or public is determined entirely by its name.
 
    If the name of a Python function, class method, or attribute starts with (but doesn't end with) two underscores, it's private; everything else is
-public.  Python has no concept of protected class methods (accessible only in their own class and descendant classes).  Class methods are either private (accessible
+public. Python has no concept of protected class methods (accessible only in their own class and descendant classes). Class methods are either private (accessible
 only in their own class) or public (accessible from anywhere).
-
    In MP3FileInfo, there are two methods: __parse and __setitem__.  As you have already discussed, __setitem__ is a special method; normally, you would call it indirectly by using the dictionary syntax on a class instance, but it is public, and you could
-call it directly (even from outside the fileinfo module) if you had a really good reason.  However, __parse is private, because it has two underscores at the beginning of its name.
+
    In MP3FileInfo, there are two methods: __parse and __setitem__. As you have already discussed, __setitem__ is a special method; normally, you would call it indirectly by using the dictionary syntax on a class instance, but it is public, and you could
+call it directly (even from outside the fileinfo module) if you had a really good reason. However, __parse is private, because it has two underscores at the beginning of its name.
    
-
@@ -3653,9 +3176,9 @@ AttributeError: 'MP3FileInfo' instance has no attribute '__parse'
 
-
@@ -3667,7 +3190,7 @@ AttributeError: 'MP3FileInfo' instance has no attribute '__parse'
 
    5.10. Summary
    
-
    That's it for the hard-core object trickery.  You'll see a real-world application of special class methods in Chapter 12, which uses getattr to create a proxy to a remote web service.
+
    That's it for the hard-core object trickery. You'll see a real-world application of special class methods in Chapter 12, which uses getattr to create a proxy to a remote web service.
 
    The next chapter will continue using this code sample to explore other Python concepts, such as exceptions, file objects, and for loops.
 
    Before diving into the next chapter, make sure you're comfortable doing all of these things:
 
    
@@ -3685,18 +3208,18 @@ AttributeError: 'MP3FileInfo' instance has no attribute '__parse'
 
    
 
    Chapter 6. Exceptions and File Handling
    
-
    In this chapter, you will dive into exceptions, file objects, for loops, and the os and sys modules.  If you've used exceptions in another programming language, you can skim the first section to get a sense of Python's syntax.  Be sure to tune in again for file handling.
+
    In this chapter, you will dive into exceptions, file objects, for loops, and the os and sys modules. If you've used exceptions in another programming language, you can skim the first section to get a sense of Python's syntax. Be sure to tune in again for file handling.
 
    6.1. Handling Exceptions
    
 
    Like many other programming languages, Python has exception handling via try...except blocks.
    
 
    
 Note
 
    
 
    In Python, all special methods (like __setitem__) and built-in attributes (like __doc__) follow a standard naming convention: they both start with and end with two underscores.  Don't name your own methods and
+In Python, all special methods (like __setitem__) and built-in attributes (like __doc__) follow a standard naming convention: they both start with and end with two underscores. Don't name your own methods and
       attributes this way, because it will only confuse you (and others) later.
 
 
    1 
 If you try to call a private method, Python will raise a slightly misleading exception, saying that the method does not exist.  Of course it does exist, but it's private,
-            so it's not accessible outside the class.Strictly speaking, private methods are accessible outside their class, just not easily accessible.  Nothing in Python is truly private; internally, the names of private methods and attributes are mangled and unmangled on the fly to make them
-            seem inaccessible by their given names.  You can access the __parse method of the MP3FileInfo class by the name _MP3FileInfo__parse.  Acknowledge that this is interesting, but promise to never, ever do it in real code.  Private methods are private for a
+If you try to call a private method, Python will raise a slightly misleading exception, saying that the method does not exist. Of course it does exist, but it's private,
+            so it's not accessible outside the class.Strictly speaking, private methods are accessible outside their class, just not easily accessible. Nothing in Python is truly private; internally, the names of private methods and attributes are mangled and unmangled on the fly to make them
+            seem inaccessible by their given names. You can access the __parse method of the MP3FileInfo class by the name _MP3FileInfo__parse. Acknowledge that this is interesting, but promise to never, ever do it in real code. Private methods are private for a
             reason, but like many other things in Python, their privateness is ultimately a matter of convention, not force.
 
 
    
-
    
 
    
 Note
 
    
 
    Python uses try...except to handle exceptions and raise to generate them.  Java and C++ use try...catch to handle exceptions, and throw to generate them.
+Python uses try...except to handle exceptions and raise to generate them. Java and C++ use try...catch to handle exceptions, and throw to generate them.
 
 
    
 
    
-
    Exceptions are everywhere in Python.  Virtually every module in the standard Python library uses them, and Python itself will raise them in a lot of different circumstances.  You've already seen them repeatedly throughout this book.
+
    Exceptions are everywhere in Python. Virtually every module in the standard Python library uses them, and Python itself will raise them in a lot of different circumstances. You've already seen them repeatedly throughout this book.
 
    
 
    Mixing datatypes without coercion will raise a TypeError exception.
 
 
-
    In each of these cases, you were simply playing around in the Python IDE: an error occurred, the exception was printed (depending on your IDE, perhaps in an intentionally jarring shade of red), and that was that.  This is called an unhandled exception.  When the exception was raised, there was no code to explicitly notice it and deal with it, so it bubbled its
-way back to the default behavior built in to Python, which is to spit out some debugging information and give up.  In the IDE, that's no big deal, but if that happened while your actual Python program was running, the entire program would come to a screeching halt.
-
    An exception doesn't need result in a complete program crash, though.  Exceptions, when raised, can be handled.  Sometimes an exception is really because you have a bug in your code (like accessing a variable that doesn't exist), but
-many times, an exception is something you can anticipate.  If you're opening a file, it might not exist.  If you're connecting
-to a database, it might be unavailable, or you might not have the correct security credentials to access it.  If you know
+
    In each of these cases, you were simply playing around in the Python IDE: an error occurred, the exception was printed (depending on your IDE, perhaps in an intentionally jarring shade of red), and that was that. This is called an unhandled exception. When the exception was raised, there was no code to explicitly notice it and deal with it, so it bubbled its
+way back to the default behavior built in to Python, which is to spit out some debugging information and give up. In the IDE, that's no big deal, but if that happened while your actual Python program was running, the entire program would come to a screeching halt.
+
    An exception doesn't need result in a complete program crash, though. Exceptions, when raised, can be handled. Sometimes an exception is really because you have a bug in your code (like accessing a variable that doesn't exist), but
+many times, an exception is something you can anticipate. If you're opening a file, it might not exist. If you're connecting
+to a database, it might be unavailable, or you might not have the correct security credentials to access it. If you know
 a line of code may raise an exception, you should handle the exception using a try...except block.
 
    Example 6.1. Opening a Non-Existent File
    >>> fsock = open("/notthere", "r")      1
 Traceback (innermost last):
   File "<interactive input>", line 1, in ?
 IOError: [Errno 2] No such file or directory: '/notthere'
 >>> try:
-...     fsock = open("/notthere")       2
+...    fsock = open("/notthere")       2
 ... except IOError:   3
-...     print "The file does not exist, exiting gracefully"
+...    print "The file does not exist, exiting gracefully"
 ... print "This line will always print" 4
 The file does not exist, exiting gracefully
 This line will always print
    
@@ -3731,7 +3254,7 @@ This line will always print
    
 
 1 
 
-Using the built-in open function, you can try to open a file for reading (more on open in the next section).  But the file doesn't exist, so this raises the IOError exception.  Since you haven't provided any explicit check for an IOError exception, Python just prints out some debugging information about what happened and then gives up.
+Using the built-in open function, you can try to open a file for reading (more on open in the next section). But the file doesn't exist, so this raises the IOError exception. Since you haven't provided any explicit check for an IOError exception, Python just prints out some debugging information about what happened and then gives up.
 
 
 
@@ -3743,29 +3266,29 @@ This line will always print
    
 
 3 
 
-When the open method raises an IOError exception, you're ready for it.  The except IOError: line catches the exception and executes your own block of code, which in this case just prints a more pleasant error message.
+When the open method raises an IOError exception, you're ready for it. The except IOError: line catches the exception and executes your own block of code, which in this case just prints a more pleasant error message.
 
 
 
 4 
 
-Once an exception has been handled, processing continues normally on the first line after the try...except block.  Note that this line will always print, whether or not an exception occurs.  If you really did have a file called
+Once an exception has been handled, processing continues normally on the first line after the try...except block. Note that this line will always print, whether or not an exception occurs. If you really did have a file called
 notthere in your root directory, the call to open would succeed, the except clause would be ignored, and this line would still be executed.
 
 
 
 
    Exceptions may seem unfriendly (after all, if you don't catch the exception, your entire program will crash), but consider
-the alternative.  Would you rather get back an unusable file object to a non-existent file?  You'd need to check its validity
+the alternative. Would you rather get back an unusable file object to a non-existent file?  You'd need to check its validity
 somehow anyway, and if you forgot, somewhere down the line, your program would give you strange errors somewhere down the
-line that you would need to trace back to the source.  I'm sure you've experienced this, and you know it's not fun.  With
+line that you would need to trace back to the source. I'm sure you've experienced this, and you know it's not fun. With
 exceptions, errors occur immediately, and you can handle them in a standard way at the source of the problem.
 
    6.1.1. Using Exceptions For Other Purposes
    
-
    There are a lot of other uses for exceptions besides handling actual error conditions.  A common use in the standard Python library is to try to import a module, and then check whether it worked.  Importing a module that does not exist will raise
-   an ImportError exception.  You can use this to define multiple levels of functionality based on which modules are available at run-time,
+
    There are a lot of other uses for exceptions besides handling actual error conditions. A common use in the standard Python library is to try to import a module, and then check whether it worked. Importing a module that does not exist will raise
+   an ImportError exception. You can use this to define multiple levels of functionality based on which modules are available at run-time,
    or to support multiple platforms (where platform-specific code is separated into different modules).
-
    You can also define your own exceptions by creating a class that inherits from the built-in Exception class, and then raise your exceptions with the raise command.  See the further reading section if you're interested in doing this.
-
    The next example demonstrates how to use an exception to support platform-specific functionality.  This code comes from the
-getpass module, a wrapper module for getting a password from the user.  Getting a password is accomplished differently on UNIX, Windows, and Mac OS platforms, but this code encapsulates all of those differences.
+
    You can also define your own exceptions by creating a class that inherits from the built-in Exception class, and then raise your exceptions with the raise command. See the further reading section if you're interested in doing this.
+
    The next example demonstrates how to use an exception to support platform-specific functionality. This code comes from the
+getpass module, a wrapper module for getting a password from the user. Getting a password is accomplished differently on UNIX, Windows, and Mac OS platforms, but this code encapsulates all of those differences.
 
    Example 6.2. Supporting Platform-Specific Functionality
       # Bind the name getpass to the appropriate function
   try:
@@ -3788,34 +3311,34 @@ exceptions, errors occur immediately, and you can handle them in a standard way
 
 1 
 
-termios is a UNIX-specific module that provides low-level control over the input terminal.  If this module is not available (because it's not
+termios is a UNIX-specific module that provides low-level control over the input terminal. If this module is not available (because it's not
                on your system, or your system doesn't support it), the import fails and Python raises an ImportError, which you catch.
 
 
 
 2 
 
-OK, you didn't have termios, so let's try msvcrt, which is a Windows-specific module that provides an API to many useful functions in the Microsoft Visual C++ runtime services.  If this import fails, Python will raise an ImportError, which you catch.
+OK, you didn't have termios, so let's try msvcrt, which is a Windows-specific module that provides an API to many useful functions in the Microsoft Visual C++ runtime services. If this import fails, Python will raise an ImportError, which you catch.
 
 
 
 3 
 
-If the first two didn't work, you try to import a function from EasyDialogs, which is a Mac OS-specific module that provides functions to pop up dialog boxes of various types.  Once again, if this import fails, Python will raise an ImportError, which you catch.
+If the first two didn't work, you try to import a function from EasyDialogs, which is a Mac OS-specific module that provides functions to pop up dialog boxes of various types. Once again, if this import fails, Python will raise an ImportError, which you catch.
 
 
 
 4 
 
 None of these platform-specific modules is available (which is possible, since Python has been ported to a lot of different platforms), so you need to fall back on a default password input function (which is
-               defined elsewhere in the getpass module).  Notice what you're doing here: assigning the function default_getpass to the variable getpass.  If you read the official getpass documentation, it tells you that the getpass module defines a getpass function.  It does this by binding getpass to the correct function for your platform.  Then when you call the getpass function, you're really calling a platform-specific function that this code has set up for you.  You don't need to know or
+               defined elsewhere in the getpass module). Notice what you're doing here: assigning the function default_getpass to the variable getpass. If you read the official getpass documentation, it tells you that the getpass module defines a getpass function. It does this by binding getpass to the correct function for your platform. Then when you call the getpass function, you're really calling a platform-specific function that this code has set up for you. You don't need to know or
                care which platform your code is running on -- just call getpass, and it will always do the right thing.
 
 
 
 5 
 
-A try...except block can have an else clause, like an if statement.  If no exception is raised during the try block, the else clause is executed afterwards.  In this case, that means that the from EasyDialogs import AskPassword import worked, so you should bind getpass to the AskPassword function.  Each of the other try...except blocks has similar else clauses to bind getpass to the appropriate function when you find an import that works.
+A try...except block can have an else clause, like an if statement. If no exception is raised during the try block, the else clause is executed afterwards. In this case, that means that the from EasyDialogs import AskPassword import worked, so you should bind getpass to the AskPassword function. Each of the other try...except blocks has similar else clauses to bind getpass to the appropriate function when you find an import that works.
 
 
 
@@ -3834,7 +3357,7 @@ exceptions, errors occur immediately, and you can handle them in a standard way
 
 
 
    6.2. Working with File Objects
    
-
    Python has a built-in function, open, for opening a file on disk.  open returns a file object, which has methods and attributes for getting information about and manipulating the opened file.
+
    Python has a built-in function, open, for opening a file on disk. open returns a file object, which has methods and attributes for getting information about and manipulating the opened file.
 
    Example 6.3. Opening a File
    >>> f = open("/music/_singles/kairo.mp3", "rb") 1
 >>> f       2
 <open file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
@@ -3846,15 +3369,15 @@ exceptions, errors occur immediately, and you can handle them in a standard way
 
 1 
 
-The open method can take up to three parameters: a filename, a mode, and a buffering parameter.  Only the first one, the filename,
-            is required; the other two are optional.  If not specified, the file is opened for reading in text mode.  Here you are opening the file for reading in binary mode.
+The open method can take up to three parameters: a filename, a mode, and a buffering parameter. Only the first one, the filename,
+            is required; the other two are optional. If not specified, the file is opened for reading in text mode. Here you are opening the file for reading in binary mode.
              (print open.__doc__ displays a great explanation of all the possible modes.)
 
 
 
 2 
 
-The open function returns an object (by now, this should not surprise you).  A file object has several useful attributes.
+The open function returns an object (by now, this should not surprise you). A file object has several useful attributes.
 
 
 
@@ -3890,15 +3413,15 @@ Rave Mix    2000http://mp3.com/DJMARYJANE     \037'
 
 1 
 
-A file object maintains state about the file it has open.  The tell method of a file object tells you your current position in the open file.  Since you haven't done anything with this file
+A file object maintains state about the file it has open. The tell method of a file object tells you your current position in the open file. Since you haven't done anything with this file
                yet, the current position is 0, which is the beginning of the file.
 
 
 
 2 
 
-The seek method of a file object moves to another position in the open file.  The second parameter specifies what the first one means;
-0 means move to an absolute position (counting from the start of the file), 1 means move to a relative position (counting from the current position), and 2 means move to a position relative to the end of the file.  Since the MP3 tags you're looking for are stored at the end of the file, you use 2 and tell the file object to move to a position 128 bytes from the end of the file.
+The seek method of a file object moves to another position in the open file. The second parameter specifies what the first one means;
+0 means move to an absolute position (counting from the start of the file), 1 means move to a relative position (counting from the current position), and 2 means move to a position relative to the end of the file. Since the MP3 tags you're looking for are stored at the end of the file, you use 2 and tell the file object to move to a position 128 bytes from the end of the file.
 
 
 
@@ -3910,21 +3433,21 @@ Rave Mix    2000http://mp3.com/DJMARYJANE     \037'
 
 4 
 
-The read method reads a specified number of bytes from the open file and returns a string with the data that was read.  The optional
-               parameter specifies the maximum number of bytes to read.  If no parameter is specified, read will read until the end of the file.  (You could have simply said read() here, since you know exactly where you are in the file and you are, in fact, reading the last 128 bytes.)  The read data
+The read method reads a specified number of bytes from the open file and returns a string with the data that was read. The optional
+               parameter specifies the maximum number of bytes to read. If no parameter is specified, read will read until the end of the file. (You could have simply said read() here, since you know exactly where you are in the file and you are, in fact, reading the last 128 bytes.)  The read data
                is assigned to the tagData variable, and the current position is updated based on how many bytes were read.
 
 
 
 5 
 
-The tell method confirms that the current position has moved.  If you do the math, you'll see that after reading 128 bytes, the position
+The tell method confirms that the current position has moved. If you do the math, you'll see that after reading 128 bytes, the position
                has been incremented by 128.
 
 
 
 
    6.2.2. Closing Files
    
-
    Open files consume system resources, and depending on the file mode, other programs may not be able to access them.  It's
+
    Open files consume system resources, and depending on the file mode, other programs may not be able to access them. It's
    important to close files as soon as you're finished with them.
 
    Example 6.5. Closing a File
     >>> f
@@ -3953,13 +3476,13 @@ ValueError: I/O operation on closed file
 
 1 
 
-The closed attribute of a file object indicates whether the object has a file open or not.  In this case, the file is still open (closed is False).
+The closed attribute of a file object indicates whether the object has a file open or not. In this case, the file is still open (closed is False).
 
 
 
 2 
 
-To close a file, call the close method of the file object.  This frees the lock (if any) that you were holding on the file, flushes buffered writes (if any)
+To close a file, call the close method of the file object. This frees the lock (if any) that you were holding on the file, flushes buffered writes (if any)
                that the system hadn't gotten around to actually writing yet, and releases the system resources.
 
 
@@ -3972,7 +3495,7 @@ ValueError: I/O operation on closed file
 
 4 
 
-Just because a file is closed doesn't mean that the file object ceases to exist.  The variable f will continue to exist until it goes out of scope or gets manually deleted.  However, none of the methods that manipulate an open file will work once the file has been closed;
+Just because a file is closed doesn't mean that the file object ceases to exist. The variable f will continue to exist until it goes out of scope or gets manually deleted. However, none of the methods that manipulate an open file will work once the file has been closed;
                they all raise an exception.
 
 
@@ -3984,7 +3507,7 @@ ValueError: I/O operation on closed file
 
 
 
    6.2.3. Handling I/O Errors
    
-
    Now you've seen enough to understand the file handling code in the fileinfo.py sample code from teh previous chapter.  This example shows how to safely open and read from a file and gracefully handle
+
    Now you've seen enough to understand the file handling code in the fileinfo.py sample code from teh previous chapter. This example shows how to safely open and read from a file and gracefully handle
    errors.
 
    Example 6.6. File Objects in MP3FileInfo
             try:              1
@@ -4003,50 +3526,50 @@ ValueError: I/O operation on closed file
 
 1 
 
-Because opening and reading files is risky and may raise an exception, all of this code is wrapped in a try...except block.  (Hey, isn't standardized indentation great?  This is where you start to appreciate it.)
+Because opening and reading files is risky and may raise an exception, all of this code is wrapped in a try...except block. (Hey, isn't standardized indentation great?  This is where you start to appreciate it.)
 
 
 
 2 
 
-The open function may raise an IOError.  (Maybe the file doesn't exist.)
+The open function may raise an IOError. (Maybe the file doesn't exist.)
 
 
 
 3 
 
-The seek method may raise an IOError.  (Maybe the file is smaller than 128 bytes.)
+The seek method may raise an IOError. (Maybe the file is smaller than 128 bytes.)
 
 
 
 4 
 
-The read method may raise an IOError.  (Maybe the disk has a bad sector, or it's on a network drive and the network just went down.)
+The read method may raise an IOError. (Maybe the disk has a bad sector, or it's on a network drive and the network just went down.)
 
 
 
 5 
 
-This is new: a try...finally block.  Once the file has been opened successfully by the open function, you want to make absolutely sure that you close it, even if an exception is raised by the seek or read methods.  That's what a try...finally block is for: code in the finally block will always be executed, even if something in the try block raises an exception.  Think of it as code that gets executed on the way out, regardless of what happened before.
+This is new: a try...finally block. Once the file has been opened successfully by the open function, you want to make absolutely sure that you close it, even if an exception is raised by the seek or read methods. That's what a try...finally block is for: code in the finally block will always be executed, even if something in the try block raises an exception. Think of it as code that gets executed on the way out, regardless of what happened before.
 
 
 
 6 
 
-At last, you handle your IOError exception.  This could be the IOError exception raised by the call to open, seek, or read.  Here, you really don't care, because all you're going to do is ignore it silently and continue.  (Remember, pass is a Python statement that does nothing.)  That's perfectly legal; “handling” an exception can mean explicitly doing nothing.  It still counts as handled, and processing will continue normally on the
+At last, you handle your IOError exception. This could be the IOError exception raised by the call to open, seek, or read. Here, you really don't care, because all you're going to do is ignore it silently and continue. (Remember, pass is a Python statement that does nothing.)  That's perfectly legal; “handling” an exception can mean explicitly doing nothing. It still counts as handled, and processing will continue normally on the
                next line of code after the try...except block.
 
 
 
 
    6.2.4. Writing to Files
    
-
    As you would expect, you can also write to files in much the same way that you read from them.  There are two basic file modes:
+
    As you would expect, you can also write to files in much the same way that you read from them. There are two basic file modes:
 
    
 
      
 
    • "Append" mode will add data to the end of the file.
 
    • "write" mode will overwrite the file.
 
    
 
    Either mode will create the file automatically if it doesn't already exist, so there's never a need for any sort of fiddly
-   "if the log file doesn't exist yet, create a new empty file just so you can open it for the first time" logic.  Just open
+   "if the log file doesn't exist yet, create a new empty file just so you can open it for the first time" logic. Just open
    it and start writing.
 
    Example 6.7. Writing to Files
     >>> logfile = open('test.log', 'w') 1
@@ -4064,7 +3587,7 @@ test succeededline 2
 
 1 
 
-You start boldly by creating either the new file test.log or overwrites the existing file, and opening the file for writing.  (The second parameter "w" means open the file for writing.)  Yes, that's all as dangerous as it sounds.  I hope you didn't care about the previous
+You start boldly by creating either the new file test.log or overwrites the existing file, and opening the file for writing. (The second parameter "w" means open the file for writing.)  Yes, that's all as dangerous as it sounds. I hope you didn't care about the previous
                contents of that file, because it's gone now.
 
 
@@ -4077,21 +3600,21 @@ test succeededline 2
 
 3 
 
-file is a synonym for open.  This one-liner opens the file, reads its contents, and prints them.
+file is a synonym for open. This one-liner opens the file, reads its contents, and prints them.
 
 
 
 4 
 
-You happen to know that test.log exists (since you just finished writing to it), so you can open it and append to it.  (The "a" parameter means open the file for appending.)  Actually you could do this even if the file didn't exist, because opening
-               the file for appending will create the file if necessary.  But appending will never harm the existing contents of the file.
+You happen to know that test.log exists (since you just finished writing to it), so you can open it and append to it. (The "a" parameter means open the file for appending.)  Actually you could do this even if the file didn't exist, because opening
+               the file for appending will create the file if necessary. But appending will never harm the existing contents of the file.
 
 
 
 5 
 
-As you can see, both the original line you wrote and the second line you appended are now in test.log.  Also note that carriage returns are not included.  Since you didn't write them explicitly to the file either time, the
-               file doesn't include them.  You can write a carriage return with the "\n" character.  Since you didn't do this, everything you wrote to the file ended up smooshed together on the same line.
+As you can see, both the original line you wrote and the second line you appended are now in test.log. Also note that carriage returns are not included. Since you didn't write them explicitly to the file either time, the
+               file doesn't include them. You can write a carriage return with the "\n" character. Since you didn't do this, everything you wrote to the file ended up smooshed together on the same line.
 
 
 
@@ -4108,12 +3631,12 @@ test succeededline 2
 
 
 
    6.3. Iterating with for Loops
    
-
    Like most other languages, Python has for loops.  The only reason you haven't seen them until now is that Python is good at so many other things that you don't need them as often.
+
    Like most other languages, Python has for loops. The only reason you haven't seen them until now is that Python is good at so many other things that you don't need them as often.
 
    Most other languages don't have a powerful list datatype like Python, so you end up doing a lot of manual work, specifying a start, end, and step to define a range of integers or characters
-or other iteratable entities.  But in Python, a for loop simply iterates over a list, the same way list comprehensions work.
+or other iteratable entities. But in Python, a for loop simply iterates over a list, the same way list comprehensions work.
 
    Example 6.8. Introducing the for Loop
    >>> li = ['a', 'b', 'e']
 >>> for s in li:         1
-...     print s          2
+...    print s          2
 a
 b
 e
@@ -4125,7 +3648,7 @@ e
    
 
 1 
 
-The syntax for a for loop is similar to list comprehensions.  li is a list, and s will take the value of each element in turn, starting from the first element.
+The syntax for a for loop is similar to list comprehensions. li is a list, and s will take the value of each element in turn, starting from the first element.
 
 
 
@@ -4137,14 +3660,14 @@ e
    
 
 3 
 
-This is the reason you haven't seen the for loop yet: you haven't needed it yet.  It's amazing how often you use for loops in other languages when all you really want is a join or a list comprehension.
+This is the reason you haven't seen the for loop yet: you haven't needed it yet. It's amazing how often you use for loops in other languages when all you really want is a join or a list comprehension.
 
 
 
 
    Doing a “normal” (by Visual Basic standards) counter for loop is also simple.
 
    Example 6.9. Simple Counters
     >>> for i in range(5):             1
-...     print i
+...    print i
 0
 1
 2
@@ -4152,7 +3675,7 @@ e
    
 4
 >>> li = ['a', 'b', 'c', 'd', 'e']
 >>> for i in range(len(li)):       2
-...     print li[i]
+...    print li[i]
 a
 b
 c
@@ -4163,22 +3686,22 @@ e
 
 1 
 
-As you saw in Example 3.20, “Assigning Consecutive Values”, range produces a list of integers, which you then loop through.  I know it looks a bit odd, but it is occasionally (and I stress
+As you saw in Example 3.20, “Assigning Consecutive Values”, range produces a list of integers, which you then loop through. I know it looks a bit odd, but it is occasionally (and I stress
 occasionally) useful to have a counter loop.
 
 
 
 2 
 
-Don't ever do this.  This is Visual Basic-style thinking.  Break out of it.  Just iterate through the list, as shown in the previous example.
+Don't ever do this. This is Visual Basic-style thinking. Break out of it. Just iterate through the list, as shown in the previous example.
 
 
 
-
    for loops are not just for simple counters.  They can iterate through all kinds of things.  Here is an example of using a for loop to iterate through a dictionary.
+
    for loops are not just for simple counters. They can iterate through all kinds of things. Here is an example of using a for loop to iterate through a dictionary.
 
    Example 6.10. Iterating Through a Dictionary
     >>> import os
 >>> for k, v in os.environ.items():      1 2
-...     print "%s=%s" % (k, v)
+...    print "%s=%s" % (k, v)
 USERPROFILE=C:\Documents and Settings\mpilgrim
 OS=Windows_NT
 COMPUTERNAME=MPILGRIM
@@ -4186,7 +3709,7 @@ USERNAME=mpilgrim
 
 [...snip...]
 >>> print "\n".join(["%s=%s" % (k, v)
-...     for k, v in os.environ.items()]) 3
+...    for k, v in os.environ.items()]) 3
 USERPROFILE=C:\Documents and Settings\mpilgrim
 OS=Windows_NT
 COMPUTERNAME=MPILGRIM
@@ -4197,22 +3720,22 @@ USERNAME=mpilgrim
 
 1 
 
-os.environ is a dictionary of the environment variables defined on your system.  In Windows, these are your user and system variables
-            accessible from MS-DOS.  In UNIX, they are the variables exported in your shell's startup scripts.  In Mac OS, there is no concept of environment variables, so this dictionary is empty.
+os.environ is a dictionary of the environment variables defined on your system. In Windows, these are your user and system variables
+            accessible from MS-DOS. In UNIX, they are the variables exported in your shell's startup scripts. In Mac OS, there is no concept of environment variables, so this dictionary is empty.
 
 
 
 2 
 
-os.environ.items() returns a list of tuples: [(key1, value1), (key2, value2), ...].  The for loop iterates through this list.  The first round, it assigns key1 to k and value1 to v, so k = USERPROFILE and v = C:\Documents and Settings\mpilgrim.  In the second round, k gets the second key, OS, and v gets the corresponding value, Windows_NT.
+os.environ.items() returns a list of tuples: [(key1, value1), (key2, value2), ...]. The for loop iterates through this list. The first round, it assigns key1 to k and value1 to v, so k = USERPROFILE and v = C:\Documents and Settings\mpilgrim. In the second round, k gets the second key, OS, and v gets the corresponding value, Windows_NT.
 
 
 
 3 
 
-With multi-variable assignment and list comprehensions, you can replace the entire for loop with a single statement.  Whether you actually do this in real code is a matter of personal coding style.  I like it
+With multi-variable assignment and list comprehensions, you can replace the entire for loop with a single statement. Whether you actually do this in real code is a matter of personal coding style. I like it
             because it makes it clear that what I'm doing is mapping a dictionary into a list, then joining the list into a single string.
-             Other programmers prefer to write this out as a for loop.  The output is the same in either case, although this version is slightly faster, because there is only one print statement instead of many.
+             Other programmers prefer to write this out as a for loop. The output is the same in either case, although this version is slightly faster, because there is only one print statement instead of many.
 
 
 
@@ -4234,26 +3757,26 @@ USERNAME=mpilgrim
 
 1 
 
-tagDataMap is a class attribute that defines the tags you're looking for in an MP3 file.  Tags are stored in fixed-length fields.  Once you read the last 128 bytes of the file, bytes 3 through 32 of those
-            are always the song title, 33 through 62 are always the artist name, 63 through 92 are the album name, and so forth.  Note
+tagDataMap is a class attribute that defines the tags you're looking for in an MP3 file. Tags are stored in fixed-length fields. Once you read the last 128 bytes of the file, bytes 3 through 32 of those
+            are always the song title, 33 through 62 are always the artist name, 63 through 92 are the album name, and so forth. Note
             that tagDataMap is a dictionary of tuples, and each tuple contains two integers and a function reference.
 
 
 
 2 
 
-This looks complicated, but it's not.  The structure of the for variables matches the structure of the elements of the list returned by items.  Remember that items returns a list of tuples of the form (key, value).  The first element of that list is ("title", (3, 33, <function stripnulls>)), so the first time around the loop, tag gets "title", start gets 3, end gets 33, and parseFunc gets the function stripnulls.
+This looks complicated, but it's not. The structure of the for variables matches the structure of the elements of the list returned by items. Remember that items returns a list of tuples of the form (key, value). The first element of that list is ("title", (3, 33, <function stripnulls>)), so the first time around the loop, tag gets "title", start gets 3, end gets 33, and parseFunc gets the function stripnulls.
 
 
 
 3 
 
-Now that you've extracted all the parameters for a single MP3 tag, saving the tag data is easy.  You slice tagdata from start to end to get the actual data for this tag, call parseFunc to post-process the data, and assign this as the value for the key tag in the pseudo-dictionary self.  After iterating through all the elements in tagDataMap, self has the values for all the tags, and you know what that looks like.
+Now that you've extracted all the parameters for a single MP3 tag, saving the tag data is easy. You slice tagdata from start to end to get the actual data for this tag, call parseFunc to post-process the data, and assign this as the value for the key tag in the pseudo-dictionary self. After iterating through all the elements in tagDataMap, self has the values for all the tags, and you know what that looks like.
 
 
 
 
    6.4. Using sys.modules
    
-
    Modules, like everything else in Python, are objects.  Once imported, you can always get a reference to a module through the global dictionary sys.modules.
+
    Modules, like everything else in Python, are objects. Once imported, you can always get a reference to a module through the global dictionary sys.modules.
 
    Example 6.12. Introducing sys.modules
    >>> import sys        1
 >>> print '\n'.join(sys.modules.keys()) 2
 win32api
@@ -4279,7 +3802,7 @@ stat
    
 
 2 
 
-sys.modules is a dictionary containing all the modules that have ever been imported since Python was started; the key is the module name, the value is the module object.  Note that this is more than just the modules your program has imported.  Python preloads some modules on startup, and if you're using a Python IDE, sys.modules contains all the modules imported by all the programs you've run within the IDE.
+sys.modules is a dictionary containing all the modules that have ever been imported since Python was started; the key is the module name, the value is the module object. Note that this is more than just the modules your program has imported. Python preloads some modules on startup, and if you're using a Python IDE, sys.modules contains all the modules imported by all the programs you've run within the IDE.
 
 
 
@@ -4308,7 +3831,7 @@ stat
 
 1 
 
-As new modules are imported, they are added to sys.modules.  This explains why importing the same module twice is very fast: Python has already loaded and cached the module in sys.modules, so importing the second time is simply a dictionary lookup.
+As new modules are imported, they are added to sys.modules. This explains why importing the same module twice is very fast: Python has already loaded and cached the module in sys.modules, so importing the second time is simply a dictionary lookup.
 
 
 
@@ -4338,7 +3861,7 @@ stat
 
 
 
-
    Now you're ready to see how sys.modules is used in fileinfo.py, the sample program introduced in Chapter 5.  This example shows that portion of the code.
+
    Now you're ready to see how sys.modules is used in fileinfo.py, the sample program introduced in Chapter 5. This example shows that portion of the code.
 
    Example 6.15. sys.modules in fileinfo.py
         def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):       1
         "get file info class from filename extension"           
@@ -4348,21 +3871,21 @@ stat
 
 1 
 
-This is a function with two arguments; filename is required, but module is optional and defaults to the module that contains the FileInfo class.  This looks inefficient, because you might expect Python to evaluate the sys.modules expression every time the function is called.  In fact, Python evaluates default expressions only once, the first time the module is imported.  As you'll see later, you never call this
+This is a function with two arguments; filename is required, but module is optional and defaults to the module that contains the FileInfo class. This looks inefficient, because you might expect Python to evaluate the sys.modules expression every time the function is called. In fact, Python evaluates default expressions only once, the first time the module is imported. As you'll see later, you never call this
             function with a module argument, so module serves as a function-level constant.
 
 
 
 2 
 
-You'll plow through this line later, after you dive into the os module.  For now, take it on faith that subclass ends up as the name of a class, like MP3FileInfo.
+You'll plow through this line later, after you dive into the os module. For now, take it on faith that subclass ends up as the name of a class, like MP3FileInfo.
 
 
 
 3 
 
-You already know about getattr, which gets a reference to an object by name.  hasattr is a complementary function that checks whether an object has a particular attribute; in this case, whether a module has
-            a particular class (although it works for any object and any attribute, just like getattr).  In English, this line of code says, “If this module has the class named by subclass then return it, otherwise return the base class FileInfo.”
+You already know about getattr, which gets a reference to an object by name. hasattr is a complementary function that checks whether an object has a particular attribute; in this case, whether a module has
+            a particular class (although it works for any object and any attribute, just like getattr). In English, this line of code says, “If this module has the class named by subclass then return it, otherwise return the base class FileInfo.”
 
 
 
@@ -4375,7 +3898,7 @@ stat
 
 
 
    6.5. Working with Directories
    
-
    The os.path module has several functions for manipulating files and directories.  Here, we're looking at handling pathnames and listing
+
    The os.path module has several functions for manipulating files and directories. Here, we're looking at handling pathnames and listing
    the contents of a directory.
 
    Example 6.16. Constructing Pathnames
     >>> import os
@@ -4391,27 +3914,27 @@ stat
 
 1 
 
-os.path is a reference to a module -- which module depends on your platform.  Just as getpass encapsulates differences between platforms by setting getpass to a platform-specific function, os encapsulates differences between platforms by setting path to a platform-specific module.
+os.path is a reference to a module -- which module depends on your platform. Just as getpass encapsulates differences between platforms by setting getpass to a platform-specific function, os encapsulates differences between platforms by setting path to a platform-specific module.
 
 
 
 2 
 
-The join function of os.path constructs a pathname out of one or more partial pathnames.  In this case, it simply concatenates strings.  (Note that dealing
+The join function of os.path constructs a pathname out of one or more partial pathnames. In this case, it simply concatenates strings. (Note that dealing
             with pathnames on Windows is annoying because the backslash character must be escaped.)
 
 
 
 3 
 
-In this slightly less trivial case, join will add an extra backslash to the pathname before joining it to the filename.  I was overjoyed when I discovered this, since
-addSlashIfNecessary is one of the stupid little functions I always need to write when building up my toolbox in a new language.  Do not write this stupid little function in Python; smart people have already taken care of it for you.
+In this slightly less trivial case, join will add an extra backslash to the pathname before joining it to the filename. I was overjoyed when I discovered this, since
+addSlashIfNecessary is one of the stupid little functions I always need to write when building up my toolbox in a new language. Do not write this stupid little function in Python; smart people have already taken care of it for you.
 
 
 
 4 
 
-expanduser will expand a pathname that uses ~ to represent the current user's home directory.  This works on any platform where users have a home directory, like Windows,
+expanduser will expand a pathname that uses ~ to represent the current user's home directory. This works on any platform where users have a home directory, like Windows,
 UNIX, and Mac OS X; it has no effect on Mac OS.
 
 
@@ -4437,14 +3960,14 @@ stat
 
 1 
 
-The split function splits a full pathname and returns a tuple containing the path and filename.  Remember when I said you could use
+The split function splits a full pathname and returns a tuple containing the path and filename. Remember when I said you could use
 multi-variable assignment to return multiple values from a function?  Well, split is such a function.
 
 
 
 2 
 
-You assign the return value of the split function into a tuple of two variables.  Each variable receives the value of the corresponding element of the returned tuple.
+You assign the return value of the split function into a tuple of two variables. Each variable receives the value of the corresponding element of the returned tuple.
 
 
 
@@ -4462,7 +3985,7 @@ stat
 
 5 
 
-os.path also contains a function splitext, which splits a filename and returns a tuple containing the filename and the file extension.   You use the same technique
+os.path also contains a function splitext, which splits a filename and returns a tuple containing the filename and the file extension.  You use the same technique
             to assign each of them to separate variables.
 
 
@@ -4479,11 +4002,11 @@ stat
 'Program Files', 'Python20', 'RECYCLER',
 'System Volume Information', 'TEMP', 'WINNT']
 >>> [f for f in os.listdir(dirname)
-...     if os.path.isfile(os.path.join(dirname, f))] 3
+...    if os.path.isfile(os.path.join(dirname, f))] 3
 ['AUTOEXEC.BAT', 'boot.ini', 'CONFIG.SYS', 'IO.SYS', 'MSDOS.SYS',
 'NTDETECT.COM', 'ntldr', 'pagefile.sys']
 >>> [f for f in os.listdir(dirname)
-...     if os.path.isdir(os.path.join(dirname, f))]  4
+...    if os.path.isdir(os.path.join(dirname, f))]  4
 ['cygwin', 'docbook', 'Documents and Settings', 'Incoming',
 'Inetpub', 'Music', 'Program Files', 'Python20', 'RECYCLER',
 'System Volume Information', 'TEMP', 'WINNT']
    
@@ -4503,13 +4026,13 @@ stat
 
 3 
 
-You can use list filtering and the isfile function of the os.path module to separate the files from the folders.  isfile takes a pathname and returns 1 if the path represents a file, and 0 otherwise.  Here you're using os.path.join to ensure a full pathname, but isfile also works with a partial path, relative to the current working directory.  You can use os.getcwd() to get the current working directory.
+You can use list filtering and the isfile function of the os.path module to separate the files from the folders. isfile takes a pathname and returns 1 if the path represents a file, and 0 otherwise. Here you're using os.path.join to ensure a full pathname, but isfile also works with a partial path, relative to the current working directory. You can use os.getcwd() to get the current working directory.
 
 
 
 4 
 
-os.path also has a isdir function which returns 1 if the path represents a directory, and 0 otherwise.  You can use this to get a list of the subdirectories
+os.path also has a isdir function which returns 1 if the path represents a directory, and 0 otherwise. You can use this to get a list of the subdirectories
             within a directory.
 
 
@@ -4532,7 +4055,7 @@ def listDirectory(directory, fileExtList):
 
 2 
 
-Iterating through the list with f, you use os.path.normcase(f) to normalize the case according to operating system defaults.  normcase is a useful little function that compensates for case-insensitive operating systems that think that mahadeva.mp3 and mahadeva.MP3 are the same file.  For instance, on Windows and Mac OS, normcase will convert the entire filename to lowercase; on UNIX-compatible systems, it will return the filename unchanged.
+Iterating through the list with f, you use os.path.normcase(f) to normalize the case according to operating system defaults. normcase is a useful little function that compensates for case-insensitive operating systems that think that mahadeva.mp3 and mahadeva.MP3 are the same file. For instance, on Windows and Mac OS, normcase will convert the entire filename to lowercase; on UNIX-compatible systems, it will return the filename unchanged.
 
 
 
@@ -4559,12 +4082,12 @@ def listDirectory(directory, fileExtList):
 Note
 
 
-Whenever possible, you should use the functions in os and os.path for file, directory, and path manipulations.  These modules are wrappers for platform-specific modules, so functions like
+Whenever possible, you should use the functions in os and os.path for file, directory, and path manipulations. These modules are wrappers for platform-specific modules, so functions like
 os.path.split work on UNIX, Windows, Mac OS, and any other platform supported by Python.
 
 
 
-
    There is one other way to get the contents of a directory.  It's very powerful, and it uses the sort of wildcards that you
+
    There is one other way to get the contents of a directory. It's very powerful, and it uses the sort of wildcards that you
 may already be familiar with from working on the command line.
 
    Example 6.20. Listing Directories with glob
     >>> os.listdir("c:\\music\\_singles\\")               1
@@ -4595,7 +4118,7 @@ may already be familiar with from working on the command line.
 2 
 
 The glob module, on the other hand, takes a wildcard and returns the full path of all files and directories matching the wildcard.
-             Here the wildcard is a directory path plus "*.mp3", which will match all .mp3 files.  Note that each element of the returned list already includes the full path of the file.
+             Here the wildcard is a directory path plus "*.mp3", which will match all .mp3 files. Note that each element of the returned list already includes the full path of the file.
 
 
 
@@ -4606,7 +4129,7 @@ may already be familiar with from working on the command line.
 
 4 
 
-Now consider this scenario: you have a music directory, with several subdirectories within it, with .mp3 files within each subdirectory.  You can get a list of all of those with a single call to glob, by using two wildcards at once.  One wildcard is the "*.mp3" (to match .mp3 files), and one wildcard is within the directory path itself, to match any subdirectory within c:\music.  That's a crazy amount of power packed into one deceptively simple-looking function!
+Now consider this scenario: you have a music directory, with several subdirectories within it, with .mp3 files within each subdirectory. You can get a list of all of those with a single call to glob, by using two wildcards at once. One wildcard is the "*.mp3" (to match .mp3 files), and one wildcard is within the directory path itself, to match any subdirectory within c:\music. That's a crazy amount of power packed into one deceptively simple-looking function!
 
 
 
@@ -4619,7 +4142,7 @@ may already be familiar with from working on the command line.
 
 
 
    6.6. Putting It All Together
    
-
    Once again, all the dominoes are in place.  You've seen how each line of code works.  Now let's step back and see how it all
+
    Once again, all the dominoes are in place. You've seen how each line of code works. Now let's step back and see how it all
    fits together.
 
    Example 6.21. listDirectory
     def listDirectory(directory, fileExtList):     1
@@ -4638,8 +4161,8 @@ def listDirectory(directory, fileExtList):     1 
 
-listDirectory is the main attraction of this entire module.  It takes a directory (like c:\music\_singles\ in my case) and a list of interesting file extensions (like ['.mp3']), and it returns a list of class instances that act like dictionaries that contain metadata about each interesting file in
-            that directory.  And it does it in just a few straightforward lines of code.
+listDirectory is the main attraction of this entire module. It takes a directory (like c:\music\_singles\ in my case) and a list of interesting file extensions (like ['.mp3']), and it returns a list of class instances that act like dictionaries that contain metadata about each interesting file in
+            that directory. And it does it in just a few straightforward lines of code.
 
 
 
@@ -4651,42 +4174,42 @@ def listDirectory(directory, fileExtList):     3 
 
-Old-school Pascal programmers may be familiar with them, but most people give me a blank stare when I tell them that Python supports nested functions -- literally, a function within a function.  The nested function getFileInfoClass can be called only from the function in which it is defined, listDirectory.  As with any other function, you don't need an interface declaration or anything fancy; just define the function and code
+Old-school Pascal programmers may be familiar with them, but most people give me a blank stare when I tell them that Python supports nested functions -- literally, a function within a function. The nested function getFileInfoClass can be called only from the function in which it is defined, listDirectory. As with any other function, you don't need an interface declaration or anything fancy; just define the function and code
             it.
 
 
 
 4 
 
-Now that you've seen the os module, this line should make more sense.  It gets the extension of the file (os.path.splitext(filename)[1]), forces it to uppercase (.upper()), slices off the dot ([1:]), and constructs a class name out of it with string formatting.  So c:\music\ap\mahadeva.mp3 becomes .mp3 becomes .MP3 becomes MP3 becomes MP3FileInfo.
+Now that you've seen the os module, this line should make more sense. It gets the extension of the file (os.path.splitext(filename)[1]), forces it to uppercase (.upper()), slices off the dot ([1:]), and constructs a class name out of it with string formatting. So c:\music\ap\mahadeva.mp3 becomes .mp3 becomes .MP3 becomes MP3 becomes MP3FileInfo.
 
 
 
 5 
 
 Having constructed the name of the handler class that would handle this file, you check to see if that handler class actually
-            exists in this module.  If it does, you return the class, otherwise you return the base class FileInfo.  This is a very important point: this function returns a class.  Not an instance of a class, but the class itself.
+            exists in this module. If it does, you return the class, otherwise you return the base class FileInfo. This is a very important point: this function returns a class. Not an instance of a class, but the class itself.
 
 
 
 6 
 
-For each file in the “interesting files” list (fileList), you call getFileInfoClass with the filename (f).  Calling getFileInfoClass(f) returns a class; you don't know exactly which class, but you don't care.  You then create an instance of this class (whatever
-            it is) and pass the filename (f again), to the __init__ method.  As you saw earlier in this chapter, the __init__ method of FileInfo sets self["name"], which triggers __setitem__, which is overridden in the descendant (MP3FileInfo) to parse the file appropriately to pull out the file's metadata.  You do all that for each interesting file and return a
+For each file in the “interesting files” list (fileList), you call getFileInfoClass with the filename (f). Calling getFileInfoClass(f) returns a class; you don't know exactly which class, but you don't care. You then create an instance of this class (whatever
+            it is) and pass the filename (f again), to the __init__ method. As you saw earlier in this chapter, the __init__ method of FileInfo sets self["name"], which triggers __setitem__, which is overridden in the descendant (MP3FileInfo) to parse the file appropriately to pull out the file's metadata. You do all that for each interesting file and return a
             list of the resulting instances.
 
 
 
-
    Note that listDirectory is completely generic.  It doesn't know ahead of time which types of files it will be getting, or which classes are defined
-that could potentially handle those files.  It inspects the directory for the files to process, and then introspects its own
-module to see what special handler classes (like MP3FileInfo) are defined.  You can extend this program to handle other types of files simply by defining an appropriately-named class:
-HTMLFileInfo for HTML files, DOCFileInfo for Word .doc files, and so forth.  listDirectory will handle them all, without modification, by handing off the real work to the appropriate classes and collating the results.
+
    Note that listDirectory is completely generic. It doesn't know ahead of time which types of files it will be getting, or which classes are defined
+that could potentially handle those files. It inspects the directory for the files to process, and then introspects its own
+module to see what special handler classes (like MP3FileInfo) are defined. You can extend this program to handle other types of files simply by defining an appropriately-named class:
+HTMLFileInfo for HTML files, DOCFileInfo for Word .doc files, and so forth. listDirectory will handle them all, without modification, by handing off the real work to the appropriate classes and collating the results.
 
    6.7. Summary
    
 
    The fileinfo.py program introduced in Chapter 5 should now make perfect sense.
 
     """Framework for getting filetype-specific metadata.
 
-Instantiate appropriate class with filename.  Returned object acts like a
+Instantiate appropriate class with filename. Returned object acts like a
 dictionary, with key-value pairs for each piece of metadata.
     import fileinfo
     info = fileinfo.MP3FileInfo("/music/ap/mahadeva.mp3")
@@ -4697,7 +4220,7 @@ Or use listDirectory function to get info on all files in a directory.
         ...
 
 Framework can be extended by adding classes for particular file types, e.g.
-HTMLFileInfo, MPGFileInfo, DOCFileInfo.  Each class is completely responsible for
+HTMLFileInfo, MPGFileInfo, DOCFileInfo. Each class is completely responsible for
 parsing its files appropriately; see MP3FileInfo for example.
 """
 import os
@@ -4776,18 +4299,18 @@ if __name__ == "__main__":
 
    
 
    Chapter 7. Regular Expressions
    
 
    Regular expressions are a powerful and standardized way of searching, replacing, and parsing text with complex patterns of
-characters.  If you've used regular expressions in other languages (like Perl), the syntax will be very familiar, and you get by just reading the summary of the re module to get an overview of the available functions and their arguments.
+characters. If you've used regular expressions in other languages (like Perl), the syntax will be very familiar, and you get by just reading the summary of the re module to get an overview of the available functions and their arguments.
 
    7.1. Diving In
    
-
    Strings have methods for searching (index, find, and count), replacing (replace), and parsing (split), but they are limited to the simplest of cases.  The search methods look for a single, hard-coded substring, and they are
-always case-sensitive.  To do case-insensitive searches of a string s, you must call s.lower() or s.upper() and make sure your search strings are the appropriate case to match.  The replace and split methods have the same limitations.
-
    If what you're trying to do can be accomplished with string functions, you should use them.  They're fast and simple and easy
-   to read, and there's a lot to be said for fast, simple, readable code.  But if you find yourself using a lot of different
+
    Strings have methods for searching (index, find, and count), replacing (replace), and parsing (split), but they are limited to the simplest of cases. The search methods look for a single, hard-coded substring, and they are
+always case-sensitive. To do case-insensitive searches of a string s, you must call s.lower() or s.upper() and make sure your search strings are the appropriate case to match. The replace and split methods have the same limitations.
+
    If what you're trying to do can be accomplished with string functions, you should use them. They're fast and simple and easy
+   to read, and there's a lot to be said for fast, simple, readable code. But if you find yourself using a lot of different
    string functions with if statements to handle special cases, or if you're combining them with split and join and list comprehensions in weird unreadable ways, you may need to move up to regular expressions.
-
    Although the regular expression syntax is tight and unlike normal code, the result can end up being more readable than a hand-rolled solution that uses a long chain of string functions.  There are even ways of embedding comments
+
    Although the regular expression syntax is tight and unlike normal code, the result can end up being more readable than a hand-rolled solution that uses a long chain of string functions. There are even ways of embedding comments
 within regular expressions to make them practically self-documenting.
 
    7.2. Case Study: Street Addresses
    
 
    This series of examples was inspired by a real-life problem I had in my day job several years ago, when I needed to scrub
-   and standardize street addresses exported from a legacy system before importing them into a newer system.  (See, I don't just
+   and standardize street addresses exported from a legacy system before importing them into a newer system. (See, I don't just
    make this stuff up; it's actually useful.)  This example shows how I approached the problem.
 
    Example 7.1. Matching at the End of a String
     >>> s = '100 NORTH MAIN ROAD'
@@ -4805,43 +4328,43 @@ within regular expressions to make them practically self-documenting.
 
 1 
 
-My goal is to standardize a street address so that 'ROAD' is always abbreviated as 'RD.'.  At first glance, I thought this was simple enough that I could just use the string method replace.  After all, all the data was already uppercase, so case mismatches would not be a problem.  And the search string, 'ROAD', was a constant.  And in this deceptively simple example, s.replace does indeed work.
+My goal is to standardize a street address so that 'ROAD' is always abbreviated as 'RD.'. At first glance, I thought this was simple enough that I could just use the string method replace. After all, all the data was already uppercase, so case mismatches would not be a problem. And the search string, 'ROAD', was a constant. And in this deceptively simple example, s.replace does indeed work.
 
 
 
 2 
 
-Life, unfortunately, is full of counterexamples, and I quickly discovered this one.  The problem here is that 'ROAD' appears twice in the address, once as part of the street name 'BROAD' and once as its own word.  The replace method sees these two occurrences and blindly replaces both of them; meanwhile, I see my addresses getting destroyed.
+Life, unfortunately, is full of counterexamples, and I quickly discovered this one. The problem here is that 'ROAD' appears twice in the address, once as part of the street name 'BROAD' and once as its own word. The replace method sees these two occurrences and blindly replaces both of them; meanwhile, I see my addresses getting destroyed.
 
 
 
 3 
 
-To solve the problem of addresses with more than one 'ROAD' substring, you could resort to something like this: only search and replace 'ROAD' in the last four characters of the address (s[-4:]), and leave the string alone (s[:-4]).  But you can see that this is already getting unwieldy.  For example, the pattern is dependent on the length of the string
-            you're replacing (if you were replacing 'STREET' with 'ST.', you would need to use s[:-6] and s[-6:].replace(...)).  Would you like to come back in six months and debug this?  I know I wouldn't.
+To solve the problem of addresses with more than one 'ROAD' substring, you could resort to something like this: only search and replace 'ROAD' in the last four characters of the address (s[-4:]), and leave the string alone (s[:-4]). But you can see that this is already getting unwieldy. For example, the pattern is dependent on the length of the string
+            you're replacing (if you were replacing 'STREET' with 'ST.', you would need to use s[:-6] and s[-6:].replace(...)). Would you like to come back in six months and debug this?  I know I wouldn't.
 
 
 
 4 
 
-It's time to move up to regular expressions.  In Python, all functionality related to regular expressions is contained in the re module.
+It's time to move up to regular expressions. In Python, all functionality related to regular expressions is contained in the re module.
 
 
 
 5 
 
-Take a look at the first parameter: 'ROAD$'.  This is a simple regular expression that matches 'ROAD' only when it occurs at the end of a string.  The $ means “end of the string”.  (There is a corresponding character, the caret ^, which means “beginning of the string”.)
+Take a look at the first parameter: 'ROAD$'. This is a simple regular expression that matches 'ROAD' only when it occurs at the end of a string. The $ means “end of the string”. (There is a corresponding character, the caret ^, which means “beginning of the string”.)
 
 
 
 6 
 
-Using the re.sub function, you search the string s for the regular expression 'ROAD$' and replace it with 'RD.'.  This matches the ROAD at the end of the string s, but does not match the ROAD that's part of the word BROAD, because that's in the middle of s.
+Using the re.sub function, you search the string s for the regular expression 'ROAD$' and replace it with 'RD.'. This matches the ROAD at the end of the string s, but does not match the ROAD that's part of the word BROAD, because that's in the middle of s.
 
 
 
 
    Continuing with my story of scrubbing addresses, I soon discovered that the previous example, matching 'ROAD' at the end of the address, was not good enough, because not all addresses included a street designation at all; some just
-ended with the street name.  Most of the time, I got away with it, but if the street name was 'BROAD', then the regular expression would match 'ROAD' at the end of the string as part of the word 'BROAD', which is not what I wanted.
+ended with the street name. Most of the time, I got away with it, but if the street name was 'BROAD', then the regular expression would match 'ROAD' at the end of the string as part of the word 'BROAD', which is not what I wanted.
 
    Example 7.2. Matching Whole Words
     >>> s = '100 BROAD'
 >>> re.sub('ROAD$', 'RD.', s)
@@ -4859,22 +4382,22 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 1 
 
-What I really wanted was to match 'ROAD' when it was at the end of the string and it was its own whole word, not a part of some larger word.  To express this in a regular expression, you use \b, which means “a word boundary must occur right here”.  In Python, this is complicated by the fact that the '\' character in a string must itself be escaped.  This is sometimes referred to as the backslash plague, and it is one reason
-            why regular expressions are easier in Perl than in Python.  On the down side, Perl mixes regular expressions with other syntax, so if you have a bug, it may be hard to tell whether it's a bug in syntax or
+What I really wanted was to match 'ROAD' when it was at the end of the string and it was its own whole word, not a part of some larger word. To express this in a regular expression, you use \b, which means “a word boundary must occur right here”. In Python, this is complicated by the fact that the '\' character in a string must itself be escaped. This is sometimes referred to as the backslash plague, and it is one reason
+            why regular expressions are easier in Perl than in Python. On the down side, Perl mixes regular expressions with other syntax, so if you have a bug, it may be hard to tell whether it's a bug in syntax or
             a bug in your regular expression.
 
 
 
 2 
 
-To work around the backslash plague, you can use what is called a raw string, by prefixing the string with the letter r.  This tells Python that nothing in this string should be escaped; '\t' is a tab character, but r'\t' is really the backslash character \ followed by the letter t.  I recommend always using raw strings when dealing with regular expressions; otherwise, things get too confusing too quickly
+To work around the backslash plague, you can use what is called a raw string, by prefixing the string with the letter r. This tells Python that nothing in this string should be escaped; '\t' is a tab character, but r'\t' is really the backslash character \ followed by the letter t. I recommend always using raw strings when dealing with regular expressions; otherwise, things get too confusing too quickly
             (and regular expressions get confusing quickly enough all by themselves).
 
 
 
 3 
 
-*sigh*  Unfortunately, I soon found more cases that contradicted my logic.  In this case, the street address contained the word
+*sigh*  Unfortunately, I soon found more cases that contradicted my logic. In this case, the street address contained the word
 'ROAD' as a whole word by itself, but it wasn't at the end, because the address had an apartment number after the street designation.
              Because 'ROAD' isn't at the very end of the string, it doesn't match, so the entire call to re.sub ends up replacing nothing at all, and you get the original string back, which is not what you want.
 
@@ -4882,13 +4405,13 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 4 
 
-To solve this problem, I removed the $ character and added another \b.  Now the regular expression reads “match 'ROAD' when it's a whole word by itself anywhere in the string,” whether at the end, the beginning, or somewhere in the middle.
+To solve this problem, I removed the $ character and added another \b. Now the regular expression reads “match 'ROAD' when it's a whole word by itself anywhere in the string,” whether at the end, the beginning, or somewhere in the middle.
 
 
 
 
    7.3. Case Study: Roman Numerals
    
-
    You've most likely seen Roman numerals, even if you didn't recognize them.  You may have seen them in copyrights of old movies
-   and television shows (“Copyright MCMXLVI” instead of “Copyright 1946”), or on the dedication walls of libraries or universities (“established MDCCCLXXXVIII” instead of “established 1888”).  You may also have seen them in outlines and bibliographical references.  It's a system of representing numbers that really
+
    You've most likely seen Roman numerals, even if you didn't recognize them. You may have seen them in copyrights of old movies
+   and television shows (“Copyright MCMXLVI” instead of “Copyright 1946”), or on the dedication walls of libraries or universities (“established MDCCCLXXXVIII” instead of “established 1888”). You may also have seen them in outlines and bibliographical references. It's a system of representing numbers that really
    does date back to the ancient Roman empire (hence the name).
 
    In Roman numerals, there are seven characters that are repeated and combined in various ways to represent numbers.
 
    
@@ -4904,21 +4427,21 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
    The following are some general rules for constructing Roman numerals:
 
    
 
      
-
    • Characters are additive.  I is 1, II is 2, and III is 3.  VI is 6 (literally, “5 and 1”), VII is 7, and VIII is 8.
+
    • Characters are additive. I is 1, II is 2, and III is 3. VI is 6 (literally, “5 and 1”), VII is 7, and VIII is 8.
 
-
    • The tens characters (I, X, C, and M) can be repeated up to three times.  At 4, you need to subtract from the next highest fives character.  You can't represent 4 as IIII; instead, it is represented as IV (“1 less than 5”).  The number 40 is written as XL (10 less than 50), 41 as XLI, 42 as XLII, 43 as XLIII, and then 44 as XLIV (10 less than 50, then 1 less than 5).
+
    • The tens characters (I, X, C, and M) can be repeated up to three times. At 4, you need to subtract from the next highest fives character. You can't represent 4 as IIII; instead, it is represented as IV (“1 less than 5”). The number 40 is written as XL (10 less than 50), 41 as XLI, 42 as XLII, 43 as XLIII, and then 44 as XLIV (10 less than 50, then 1 less than 5).
 
-
    • Similarly, at 9, you need to subtract from the next highest tens character: 8 is VIII, but 9 is IX (1 less than 10), not VIIII (since the I character can not be repeated four times).  The number 90 is XC, 900 is CM.
+
    • Similarly, at 9, you need to subtract from the next highest tens character: 8 is VIII, but 9 is IX (1 less than 10), not VIIII (since the I character can not be repeated four times). The number 90 is XC, 900 is CM.
 
-
    • The fives characters can not be repeated.  The number 10 is always represented as X, never as VV.  The number 100 is always C, never LL.
+
    • The fives characters can not be repeated. The number 10 is always represented as X, never as VV. The number 100 is always C, never LL.
 
 
    • Roman numerals are always written highest to lowest, and read left to right, so the order the of characters matters very much.
-       DC is 600; CD is a completely different number (400, 100 less than 500).  CI is 101; IC is not even a valid Roman numeral (because you can't subtract 1 directly from 100; you would need to write it as XCIX, for 10 less than 100, then 1 less than 10).
+       DC is 600; CD is a completely different number (400, 100 less than 500). CI is 101; IC is not even a valid Roman numeral (because you can't subtract 1 directly from 100; you would need to write it as XCIX, for 10 less than 100, then 1 less than 10).
 
 
    
 
    7.3.1. Checking for Thousands
    
-
    What would it take to validate that an arbitrary string is a valid Roman numeral?  Let's take it one digit at a time.  Since
-   Roman numerals are always written highest to lowest, let's start with the highest: the thousands place.  For numbers 1000
+
    What would it take to validate that an arbitrary string is a valid Roman numeral?  Let's take it one digit at a time. Since
+   Roman numerals are always written highest to lowest, let's start with the highest: the thousands place. For numbers 1000
    and higher, the thousands are represented by a series of M characters.
 
    Example 7.3. Checking for Thousands
     >>> import re
@@ -4939,12 +4462,12 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 This pattern has three parts:
 
    
 
      
-
    • ^ to match what follows only at the beginning of the string.  If this were not specified, the pattern would match no matter
-      where the M characters were, which is not what you want.  You want to make sure that the M characters, if they're there, are at the beginning of the string.
+
    • ^ to match what follows only at the beginning of the string. If this were not specified, the pattern would match no matter
+      where the M characters were, which is not what you want. You want to make sure that the M characters, if they're there, are at the beginning of the string.
 
-
    • M? to optionally match a single M character.  Since this is repeated three times, you're matching anywhere from zero to three M characters in a row.
+
    • M? to optionally match a single M character. Since this is repeated three times, you're matching anywhere from zero to three M characters in a row.
 
-
    • $ to match what precedes only at the end of the string.  When combined with the ^ character at the beginning, this means that the pattern must match the entire string, with no other characters before or
+
    • $ to match what precedes only at the end of the string. When combined with the ^ character at the beginning, this means that the pattern must match the entire string, with no other characters before or
       after the M characters.
 
 
    
@@ -4953,8 +4476,8 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 2 
 
-The essence of the re module is the search function, that takes a regular expression (pattern) and a string ('M') to try to match against the regular expression.  If a match is found, search returns an object which has various methods to describe the match; if no match is found, search returns None, the Python null value.  All you care about at the moment is whether the pattern matches, which you can tell by just looking at the return
-               value of search.  'M' matches this regular expression, because the first optional M matches and the second and third optional M characters are ignored.
+The essence of the re module is the search function, that takes a regular expression (pattern) and a string ('M') to try to match against the regular expression. If a match is found, search returns an object which has various methods to describe the match; if no match is found, search returns None, the Python null value. All you care about at the moment is whether the pattern matches, which you can tell by just looking at the return
+               value of search. 'M' matches this regular expression, because the first optional M matches and the second and third optional M characters are ignored.
 
 
 
@@ -4972,7 +4495,7 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 5 
 
-'MMMM' does not match.  All three M characters match, but then the regular expression insists on the string ending (because of the $ character), and the string doesn't end yet (because of the fourth M).  So search returns None.
+'MMMM' does not match. All three M characters match, but then the regular expression insists on the string ending (because of the $ character), and the string doesn't end yet (because of the fourth M). So search returns None.
 
 
 
@@ -5030,33 +4553,33 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 1 
 
-This pattern starts out the same as the previous one, checking for the beginning of the string (^), then the thousands place (M?M?M?).  Then it has the new part, in parentheses, which defines a set of three mutually exclusive patterns, separated by vertical
-               bars: CM, CD, and D?C?C?C? (which is an optional D followed by zero to three optional C characters).  The regular expression parser checks for each of these patterns in order (from left to right), takes the first
+This pattern starts out the same as the previous one, checking for the beginning of the string (^), then the thousands place (M?M?M?). Then it has the new part, in parentheses, which defines a set of three mutually exclusive patterns, separated by vertical
+               bars: CM, CD, and D?C?C?C? (which is an optional D followed by zero to three optional C characters). The regular expression parser checks for each of these patterns in order (from left to right), takes the first
                one that matches, and ignores the rest.
 
 
 
 2 
 
-'MCM' matches because the first M matches, the second and third M characters are ignored, and the CM matches (so the CD and D?C?C?C? patterns are never even considered).  MCM is the Roman numeral representation of 1900.
+'MCM' matches because the first M matches, the second and third M characters are ignored, and the CM matches (so the CD and D?C?C?C? patterns are never even considered). MCM is the Roman numeral representation of 1900.
 
 
 
 3 
 
-'MD' matches because the first M matches, the second and third M characters are ignored, and the D?C?C?C? pattern matches D (each of the three C characters are optional and are ignored).  MD is the Roman numeral representation of 1500.
+'MD' matches because the first M matches, the second and third M characters are ignored, and the D?C?C?C? pattern matches D (each of the three C characters are optional and are ignored). MD is the Roman numeral representation of 1500.
 
 
 
 4 
 
-'MMMCCC' matches because all three M characters match, and the D?C?C?C? pattern matches CCC (the D is optional and is ignored).  MMMCCC is the Roman numeral representation of 3300.
+'MMMCCC' matches because all three M characters match, and the D?C?C?C? pattern matches CCC (the D is optional and is ignored). MMMCCC is the Roman numeral representation of 3300.
 
 
 
 5 
 
-'MCMC' does not match.  The first M matches, the second and third M characters are ignored, and the CM matches, but then the $ does not match because you're not at the end of the string yet (you still have an unmatched C character).  The C does not match as part of the D?C?C?C? pattern, because the mutually exclusive CM pattern has already matched.
+'MCMC' does not match. The first M matches, the second and third M characters are ignored, and the CM matches, but then the $ does not match because you're not at the end of the string yet (you still have an unmatched C character). The C does not match as part of the D?C?C?C? pattern, because the mutually exclusive CM pattern has already matched.
 
 
 
@@ -5067,11 +4590,11 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 
 
    Whew!  See how quickly regular expressions can get nasty?  And you've only covered the thousands and hundreds places of Roman
-   numerals.  But if you followed all that, the tens and ones places are easy, because they're exactly the same pattern.  But
+   numerals. But if you followed all that, the tens and ones places are easy, because they're exactly the same pattern. But
    let's look at another way to express the pattern.
 
    7.4. Using the {n,m} Syntax
    
-
    In the previous section, you were dealing with a pattern where the same character could be repeated up to three times.  There is another way to express
-   this in regular expressions, which some people find more readable.  First look at the method we already used in the previous
+
    In the previous section, you were dealing with a pattern where the same character could be repeated up to three times. There is another way to express
+   this in regular expressions, which some people find more readable. First look at the method we already used in the previous
    example.
 
    Example 7.5. The Old Way: Every Character Optional
     >>> import re
@@ -5152,7 +4675,7 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 5 
 
-This matches the start of the string, then three M out of a possible three, but then does not match the end of the string.  The regular expression allows for up to only three M characters before the end of the string, but you have four, so the pattern does not match and returns None.
+This matches the start of the string, then three M out of a possible three, but then does not match the end of the string. The regular expression allows for up to only three M characters before the end of the string, but you have four, so the pattern does not match and returns None.
 
 
 
@@ -5161,14 +4684,14 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 Note
 
 
-There is no way to programmatically determine that two regular expressions are equivalent.  The best you can do is write a
-      lot of test cases to make sure they behave the same way on all relevant inputs.  You'll talk more about writing test cases
+There is no way to programmatically determine that two regular expressions are equivalent. The best you can do is write a
+      lot of test cases to make sure they behave the same way on all relevant inputs. You'll talk more about writing test cases
       later in this book.
 
 
 
 
    7.4.1. Checking for Tens and Ones
    
-
    Now let's expand the Roman numeral regular expression to cover the tens and ones place.  This example shows the check for
+
    Now let's expand the Roman numeral regular expression to cover the tens and ones place. This example shows the check for
    tens.
 
    Example 7.7. Checking for Tens
     >>> pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$'
@@ -5187,35 +4710,35 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 1 
 
-This matches the start of the string, then the first optional M, then CM, then XL, then the end of the string.  Remember, the (A|B|C) syntax means “match exactly one of A, B, or C”.  You match XL, so you ignore the XC and L?X?X?X? choices, and then move on to the end of the string.  MCML is the Roman numeral representation of 1940.
+This matches the start of the string, then the first optional M, then CM, then XL, then the end of the string. Remember, the (A|B|C) syntax means “match exactly one of A, B, or C”. You match XL, so you ignore the XC and L?X?X?X? choices, and then move on to the end of the string. MCML is the Roman numeral representation of 1940.
 
 
 
 2 
 
-This matches the start of the string, then the first optional M, then CM, then L?X?X?X?.  Of the L?X?X?X?, it matches the L and skips all three optional X characters.  Then you move to the end of the string.  MCML is the Roman numeral representation of 1950.
+This matches the start of the string, then the first optional M, then CM, then L?X?X?X?. Of the L?X?X?X?, it matches the L and skips all three optional X characters. Then you move to the end of the string. MCML is the Roman numeral representation of 1950.
 
 
 
 3 
 
-This matches the start of the string, then the first optional M, then CM, then the optional L and the first optional X, skips the second and third optional X, then the end of the string.  MCMLX is the Roman numeral representation of 1960.
+This matches the start of the string, then the first optional M, then CM, then the optional L and the first optional X, skips the second and third optional X, then the end of the string. MCMLX is the Roman numeral representation of 1960.
 
 
 
 4 
 
-This matches the start of the string, then the first optional M, then CM, then the optional L and all three optional X characters, then the end of the string.  MCMLXXX is the Roman numeral representation of 1980.
+This matches the start of the string, then the first optional M, then CM, then the optional L and all three optional X characters, then the end of the string. MCMLXXX is the Roman numeral representation of 1980.
 
 
 
 5 
 
-This matches the start of the string, then the first optional M, then CM, then the optional L and all three optional X characters, then fails to match the end of the string because there is still one more X unaccounted for.  So the entire pattern fails to match, and returns None.  MCMLXXXX is not a valid Roman numeral.
+This matches the start of the string, then the first optional M, then CM, then the optional L and all three optional X characters, then fails to match the end of the string because there is still one more X unaccounted for. So the entire pattern fails to match, and returns None. MCMLXXXX is not a valid Roman numeral.
 
 
 
-
    The expression for the ones place follows the same pattern.  I'll spare you the details and show you the end result.
+
    The expression for the ones place follows the same pattern. I'll spare you the details and show you the end result.
 
     >>> pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$'
 
    So what does that look like using this alternate {n,m} syntax?  This example shows the new syntax.
@@ -5234,48 +4757,48 @@ ended with the street name.  Most of the time, I got away with it, but if the st
 
 1 
 
-This matches the start of the string, then one of a possible four M characters, then D?C{0,3}.  Of that, it matches the optional D and zero of three possible C characters.  Moving on, it matches L?X{0,3} by matching the optional L and zero of three possible X characters.  Then it matches V?I{0,3} by matching the optional V and zero of three possible I characters, and finally the end of the string.  MDLV is the Roman numeral representation of 1555.
+This matches the start of the string, then one of a possible four M characters, then D?C{0,3}. Of that, it matches the optional D and zero of three possible C characters. Moving on, it matches L?X{0,3} by matching the optional L and zero of three possible X characters. Then it matches V?I{0,3} by matching the optional V and zero of three possible I characters, and finally the end of the string. MDLV is the Roman numeral representation of 1555.
 
 
 
 2 
 
-This matches the start of the string, then two of a possible four M characters, then the D?C{0,3} with a D and one of three possible C characters; then L?X{0,3} with an L and one of three possible X characters; then V?I{0,3} with a V and one of three possible I characters; then the end of the string.  MMDCLXVI is the Roman numeral representation of 2666.
+This matches the start of the string, then two of a possible four M characters, then the D?C{0,3} with a D and one of three possible C characters; then L?X{0,3} with an L and one of three possible X characters; then V?I{0,3} with a V and one of three possible I characters; then the end of the string. MMDCLXVI is the Roman numeral representation of 2666.
 
 
 
 3 
 
-This matches the start of the string, then four out of four M characters, then D?C{0,3} with a D and three out of three C characters; then L?X{0,3} with an L and three out of three X characters; then V?I{0,3} with a V and three out of three I characters; then the end of the string.  MMMMDCCCLXXXVIII is the Roman numeral representation of 3888, and it's the longest Roman numeral you can write without extended syntax.
+This matches the start of the string, then four out of four M characters, then D?C{0,3} with a D and three out of three C characters; then L?X{0,3} with an L and three out of three X characters; then V?I{0,3} with a V and three out of three I characters; then the end of the string. MMMMDCCCLXXXVIII is the Roman numeral representation of 3888, and it's the longest Roman numeral you can write without extended syntax.
 
 
 
 4 
 
-Watch closely.  (I feel like a magician.  “Watch closely, kids, I'm going to pull a rabbit out of my hat.”)  This matches the start of the string, then zero out of four M, then matches D?C{0,3} by skipping the optional D and matching zero out of three C, then matches L?X{0,3} by skipping the optional L and matching zero out of three X, then matches V?I{0,3} by skipping the optional V and matching one out of three I.  Then the end of the string.  Whoa.
+Watch closely. (I feel like a magician. “Watch closely, kids, I'm going to pull a rabbit out of my hat.”)  This matches the start of the string, then zero out of four M, then matches D?C{0,3} by skipping the optional D and matching zero out of three C, then matches L?X{0,3} by skipping the optional L and matching zero out of three X, then matches V?I{0,3} by skipping the optional V and matching one out of three I. Then the end of the string. Whoa.
 
 
 
-
    If you followed all that and understood it on the first try, you're doing better than I did.  Now imagine trying to understand
-   someone else's regular expressions, in the middle of a critical function of a large program.  Or even imagine coming back
-   to your own regular expressions a few months later.  I've done it, and it's not a pretty sight.
+
    If you followed all that and understood it on the first try, you're doing better than I did. Now imagine trying to understand
+   someone else's regular expressions, in the middle of a critical function of a large program. Or even imagine coming back
+   to your own regular expressions a few months later. I've done it, and it's not a pretty sight.
 
    In the next section you'll explore an alternate syntax that can help keep your expressions maintainable.
 
    7.5. Verbose Regular Expressions
    
-
    So far you've just been dealing with what I'll call “compact” regular expressions.  As you've seen, they are difficult to read, and even if you figure out what one does, that's no guarantee
-   that you'll be able to understand it six months later.  What you really need is inline documentation.
-
    Python allows you to do this with something called verbose regular expressions.  A verbose regular expression is different from a compact regular expression in two ways:
+
    So far you've just been dealing with what I'll call “compact” regular expressions. As you've seen, they are difficult to read, and even if you figure out what one does, that's no guarantee
+   that you'll be able to understand it six months later. What you really need is inline documentation.
+
    Python allows you to do this with something called verbose regular expressions. A verbose regular expression is different from a compact regular expression in two ways:
 
    
 
      
-
    • Whitespace is ignored.  Spaces, tabs, and carriage returns are not matched as spaces, tabs, and carriage returns.  They're
-      not matched at all.  (If you want to match a space in a verbose regular expression, you'll need to escape it by putting a
+
    • Whitespace is ignored. Spaces, tabs, and carriage returns are not matched as spaces, tabs, and carriage returns. They're
+      not matched at all. (If you want to match a space in a verbose regular expression, you'll need to escape it by putting a
       backslash in front of it.)
 
-
    • Comments are ignored.  A comment in a verbose regular expression is just like a comment in Python code: it starts with a # character and goes until the end of the line.  In this case it's a comment within a multi-line string instead of within your
+
    • Comments are ignored. A comment in a verbose regular expression is just like a comment in Python code: it starts with a # character and goes until the end of the line. In this case it's a comment within a multi-line string instead of within your
       source code, but it works the same way.
 
 
    
-
    This will be more clear with an example.  Let's revisit the compact regular expression you've been working with, and make
-it a verbose regular expression.  This example shows how.
+
    This will be more clear with an example. Let's revisit the compact regular expression you've been working with, and make
+it a verbose regular expression. This example shows how.
 
    Example 7.9. Regular Expressions with Inline Comments
     >>> pattern = """
     ^ # beginning of string
@@ -5301,8 +4824,8 @@ it a verbose regular expression.  This example shows how.
 1 
 
 The most important thing to remember when using verbose regular expressions is that you need to pass an extra argument when
-            working with them: re.VERBOSE is a constant defined in the re module that signals that the pattern should be treated as a verbose regular expression.  As you can see, this pattern has
-            quite a bit of whitespace (all of which is ignored), and several comments (all of which are ignored).  Once you ignore the
+            working with them: re.VERBOSE is a constant defined in the re module that signals that the pattern should be treated as a verbose regular expression. As you can see, this pattern has
+            quite a bit of whitespace (all of which is ignored), and several comments (all of which are ignored). Once you ignore the
             whitespace and the comments, this is exactly the same regular expression as you saw in the previous section, but it's a lot more readable.
 
 
@@ -5321,16 +4844,16 @@ it a verbose regular expression.  This example shows how.
 
 4 
 
-This does not match.  Why?  Because it doesn't have the re.VERBOSE flag, so the re.search function is treating the pattern as a compact regular expression, with significant whitespace and literal hash marks.  Python can't auto-detect whether a regular expression is verbose or not.  Python assumes every regular expression is compact unless you explicitly state that it is verbose.
+This does not match. Why?  Because it doesn't have the re.VERBOSE flag, so the re.search function is treating the pattern as a compact regular expression, with significant whitespace and literal hash marks. Python can't auto-detect whether a regular expression is verbose or not. Python assumes every regular expression is compact unless you explicitly state that it is verbose.
 
 
 
 
    7.6. Case study: Parsing Phone Numbers
    
-
    So far you've concentrated on matching whole patterns.  Either the pattern matches, or it doesn't.  But regular expressions
-   are much more powerful than that.  When a regular expression does match, you can pick out specific pieces of it.  You can find out what matched where.
-
    This example came from another real-world problem I encountered, again from a previous day job.  The problem: parsing an American
-phone number.  The client wanted to be able to enter the number free-form (in a single field), but then wanted to store the
-area code, trunk, number, and optionally an extension separately in the company's database.  I scoured the Web and found many
+
    So far you've concentrated on matching whole patterns. Either the pattern matches, or it doesn't. But regular expressions
+   are much more powerful than that. When a regular expression does match, you can pick out specific pieces of it. You can find out what matched where.
+
    This example came from another real-world problem I encountered, again from a previous day job. The problem: parsing an American
+phone number. The client wanted to be able to enter the number free-form (in a single field), but then wanted to store the
+area code, trunk, number, and optionally an extension separately in the company's database. I scoured the Web and found many
 examples of regular expressions that purported to do this, but none of them were permissive enough.
 
    Here are the phone numbers I needed to be able to accept:
 
    
@@ -5345,8 +4868,8 @@ examples of regular expressions that purported to do this, but none of them were
 
  • 800-555-1212 ext. 1234
 
  • work 1-(800) 555.1212 #1234
 
-
    Quite a variety!  In each of these cases, I need to know that the area code was 800, the trunk was 555, and the rest of the phone number was 1212.  For those with an extension, I need to know that the extension was 1234.
-
    Let's work through developing a solution for phone number parsing.  This example shows the first step.
+
    Quite a variety!  In each of these cases, I need to know that the area code was 800, the trunk was 555, and the rest of the phone number was 1212. For those with an extension, I need to know that the extension was 1234.
+
    Let's work through developing a solution for phone number parsing. This example shows the first step.
 
    Example 7.10. Finding Numbers
     >>> phonePattern = re.compile(r'^(\d{3})-(\d{3})-(\d{4})$') 1
 >>> phonePattern.search('800-555-1212').groups()            2
@@ -5358,21 +4881,21 @@ examples of regular expressions that purported to do this, but none of them were
 
 1 
 
-Always read regular expressions from left to right.  This one matches the beginning of the string, and then (\d{3}).  What's \d{3}?  Well, the {3} means “match exactly three numeric digits”; it's a variation on the {n,m} syntax you saw earlier.  \d means “any numeric digit” (0 through 9).  Putting it in parentheses means “match exactly three numeric digits, and then remember them as a group that I can ask for later”.  Then match a literal hyphen.  Then match another group of exactly three digits.  Then another literal hyphen.  Then another
-            group of exactly four digits.  Then match the end of the string.
+Always read regular expressions from left to right. This one matches the beginning of the string, and then (\d{3}). What's \d{3}?  Well, the {3} means “match exactly three numeric digits”; it's a variation on the {n,m} syntax you saw earlier. \d means “any numeric digit” (0 through 9). Putting it in parentheses means “match exactly three numeric digits, and then remember them as a group that I can ask for later”. Then match a literal hyphen. Then match another group of exactly three digits. Then another literal hyphen. Then another
+            group of exactly four digits. Then match the end of the string.
 
 
 
 2 
 
-To get access to the groups that the regular expression parser remembered along the way, use the groups() method on the object that the search function returns.  It will return a tuple of however many groups were defined in the regular expression.  In this case, you
+To get access to the groups that the regular expression parser remembered along the way, use the groups() method on the object that the search function returns. It will return a tuple of however many groups were defined in the regular expression. In this case, you
             defined three groups, one with three digits, one with three digits, and one with four digits.
 
 
 
 3 
 
-This regular expression is not the final answer, because it doesn't handle a phone number with an extension on the end.  For
+This regular expression is not the final answer, because it doesn't handle a phone number with an extension on the end. For
             that, you'll need to expand the regular expression.
 
 
@@ -5390,9 +4913,9 @@ examples of regular expressions that purported to do this, but none of them were
 
 1 
 
-This regular expression is almost identical to the previous one.  Just as before, you match the beginning of the string, then
+This regular expression is almost identical to the previous one. Just as before, you match the beginning of the string, then
             a remembered group of three digits, then a hyphen, then a remembered group of three digits, then a hyphen, then a remembered
-            group of four digits.  What's new is that you then match another hyphen, and a remembered group of one or more digits, then
+            group of four digits. What's new is that you then match another hyphen, and a remembered group of one or more digits, then
             the end of the string.
 
 
@@ -5406,7 +4929,7 @@ examples of regular expressions that purported to do this, but none of them were
 3 
 
 Unfortunately, this regular expression is not the final answer either, because it assumes that the different parts of the
-            phone number are separated by hyphens.  What if they're separated by spaces, or commas, or dots?  You need a more general
+            phone number are separated by hyphens. What if they're separated by spaces, or commas, or dots?  You need a more general
             solution to match several different types of separators.
 
 
@@ -5414,7 +4937,7 @@ examples of regular expressions that purported to do this, but none of them were
 4 
 
 Oops!  Not only does this regular expression not do everything you want, it's actually a step backwards, because now you can't
-            parse phone numbers without an extension.  That's not what you wanted at all; if the extension is there, you want to know what it is, but if it's not
+            parse phone numbers without an extension. That's not what you wanted at all; if the extension is there, you want to know what it is, but if it's not
             there, you still want to know what the different parts of the main number are.
 
 
@@ -5435,7 +4958,7 @@ examples of regular expressions that purported to do this, but none of them were
 
 1 
 
-Hang on to your hat.  You're matching the beginning of the string, then a group of three digits, then \D+.  What the heck is that?  Well, \D matches any character except a numeric digit, and + means “1 or more”.  So \D+ matches one or more characters that are not digits.  This is what you're using instead of a literal hyphen, to try to match
+Hang on to your hat. You're matching the beginning of the string, then a group of three digits, then \D+. What the heck is that?  Well, \D matches any character except a numeric digit, and + means “1 or more”. So \D+ matches one or more characters that are not digits. This is what you're using instead of a literal hyphen, to try to match
             different separators.
 
 
@@ -5453,14 +4976,14 @@ examples of regular expressions that purported to do this, but none of them were
 
 4 
 
-Unfortunately, this is still not the final answer, because it assumes that there is a separator at all.  What if the phone
+Unfortunately, this is still not the final answer, because it assumes that there is a separator at all. What if the phone
             number is entered without any spaces or hyphens at all?
 
 
 
 4 
 
-Oops!  This still hasn't fixed the problem of requiring extensions.  Now you have two problems, but you can solve both of
+Oops!  This still hasn't fixed the problem of requiring extensions. Now you have two problems, but you can solve both of
             them with the same technique.
 
 
@@ -5481,13 +5004,13 @@ examples of regular expressions that purported to do this, but none of them were
 
 1 
 
-The only change you've made since that last step is changing all the + to *.  Instead of \D+ between the parts of the phone number, you now match on \D*.  Remember that + means “1 or more”?  Well, * means “zero or more”.  So now you should be able to parse phone numbers even when there is no separator character at all.
+The only change you've made since that last step is changing all the + to *. Instead of \D+ between the parts of the phone number, you now match on \D*. Remember that + means “1 or more”?  Well, * means “zero or more”. So now you should be able to parse phone numbers even when there is no separator character at all.
 
 
 
 2 
 
-Lo and behold, it actually works.  Why?  You matched the beginning of the string, then a remembered group of three digits
+Lo and behold, it actually works. Why?  You matched the beginning of the string, then a remembered group of three digits
             (800), then zero non-numeric characters, then a remembered group of three digits (555), then zero non-numeric characters, then a remembered group of four digits (1212), then zero non-numeric characters, then a remembered group of an arbitrary number of digits (1234), then the end of the string.
 
 
@@ -5500,14 +5023,14 @@ examples of regular expressions that purported to do this, but none of them were
 
 4 
 
-Finally, you've solved the other long-standing problem: extensions are optional again.  If no extension is found, the groups() method still returns a tuple of four elements, but the fourth element is just an empty string.
+Finally, you've solved the other long-standing problem: extensions are optional again. If no extension is found, the groups() method still returns a tuple of four elements, but the fourth element is just an empty string.
 
 
 
 5 
 
-I hate to be the bearer of bad news, but you're not finished yet.  What's the problem here?  There's an extra character before
-            the area code, but the regular expression assumes that the area code is the first thing at the beginning of the string.  No
+I hate to be the bearer of bad news, but you're not finished yet. What's the problem here?  There's an extra character before
+            the area code, but the regular expression assumes that the area code is the first thing at the beginning of the string. No
             problem, you can use the same technique of “zero or more non-numeric characters” to skip over the leading characters before the area code.
 
 
@@ -5526,22 +5049,22 @@ examples of regular expressions that purported to do this, but none of them were
 
 1 
 
-This is the same as in the previous example, except now you're matching \D*, zero or more non-numeric characters, before the first remembered group (the area code).  Notice that you're not remembering
-            these non-numeric characters (they're not in parentheses).  If you find them, you'll just skip over them and then start remembering
+This is the same as in the previous example, except now you're matching \D*, zero or more non-numeric characters, before the first remembered group (the area code). Notice that you're not remembering
+            these non-numeric characters (they're not in parentheses). If you find them, you'll just skip over them and then start remembering
             the area code whenever you get to it.
 
 
 
 2 
 
-You can successfully parse the phone number, even with the leading left parenthesis before the area code.  (The right parenthesis
+You can successfully parse the phone number, even with the leading left parenthesis before the area code. (The right parenthesis
             after the area code is already handled; it's treated as a non-numeric separator and matched by the \D* after the first remembered group.)
 
 
 
 3 
 
-Just a sanity check to make sure you haven't broken anything that used to work.  Since the leading characters are entirely
+Just a sanity check to make sure you haven't broken anything that used to work. Since the leading characters are entirely
             optional, this matches the beginning of the string, then zero non-numeric characters, then a remembered group of three digits
             (800), then one non-numeric character (the hyphen), then a remembered group of three digits (555), then one non-numeric character (the hyphen), then a remembered group of four digits (1212), then zero non-numeric characters, then a remembered group of zero digits, then the end of the string.
 
@@ -5549,15 +5072,15 @@ examples of regular expressions that purported to do this, but none of them were
 
 4 
 
-This is where regular expressions make me want to gouge my eyes out with a blunt object.  Why doesn't this phone number match?
-             Because there's a 1 before the area code, but you assumed that all the leading characters before the area code were non-numeric characters (\D*).  Aargh.
+This is where regular expressions make me want to gouge my eyes out with a blunt object. Why doesn't this phone number match?
+             Because there's a 1 before the area code, but you assumed that all the leading characters before the area code were non-numeric characters (\D*). Aargh.
 
 
 
-
    Let's back up for a second.  So far the regular expressions have all matched from the beginning of the string.  But now you
-see that there may be an indeterminate amount of stuff at the beginning of the string that you want to ignore.  Rather than
+
    Let's back up for a second. So far the regular expressions have all matched from the beginning of the string. But now you
+see that there may be an indeterminate amount of stuff at the beginning of the string that you want to ignore. Rather than
 trying to match it all just so you can skip over it, let's take a different approach: don't explicitly match the beginning
-of the string at all.  This approach is shown in the next example.
+of the string at all. This approach is shown in the next example.
 
    Example 7.15. Phone Number, Wherever I May Find Ye
     >>> phonePattern = re.compile(r'(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') 1
 >>> phonePattern.search('work 1-(800) 555.1212 #1234').groups()        2
@@ -5571,8 +5094,8 @@ of the string at all.  This approach is shown in the next example.
 
 1 
 
-Note the lack of ^ in this regular expression.  You are not matching the beginning of the string anymore.  There's nothing that says you need
-            to match the entire input with your regular expression.  The regular expression engine will do the hard work of figuring out
+Note the lack of ^ in this regular expression. You are not matching the beginning of the string anymore. There's nothing that says you need
+            to match the entire input with your regular expression. The regular expression engine will do the hard work of figuring out
             where the input string starts to match, and go from there.
 
 
@@ -5586,7 +5109,7 @@ of the string at all.  This approach is shown in the next example.
 
 3 
 
-Sanity check.  this still works.
+Sanity check. this still works.
 
 
 4 
@@ -5594,7 +5117,7 @@ of the string at all.  This approach is shown in the next example.
 That still works too.
 
 
-
    See how quickly a regular expression can get out of control?  Take a quick glance at any of the previous iterations.  Can
+
    See how quickly a regular expression can get out of control?  Take a quick glance at any of the previous iterations. Can
 you tell the difference between one and the next?
 
    While you still understand the final answer (and it is the final answer; if you've discovered a case it doesn't handle, I
 don't want to know about it), let's write it out as a verbose regular expression, before you forget why you made the choices
@@ -5627,7 +5150,7 @@ you made.
 
 2 
 
-Final sanity check.  Yes, this still works.  You're done.
+Final sanity check. Yes, this still works. You're done.
 
 
 
    
@@ -5639,7 +5162,7 @@ you made.
 
 
 
    7.7. Summary
    
-
    This is just the tiniest tip of the iceberg of what regular expressions can do.  In other words, even though you're completely
+
    This is just the tiniest tip of the iceberg of what regular expressions can do. In other words, even though you're completely
    overwhelmed by them now, believe me, you ain't seen nothing yet.
 
    You should now be familiar with the following techniques:
 
    
@@ -5664,10 +5187,10 @@ you made.
 
 
  • (a|b|c) matches either a or b or c.
 
-
  • (x) in general is a remembered group.  You can get the value of what matched by using the groups() method of the object returned by re.search.
+
  • (x) in general is a remembered group. You can get the value of what matched by using the groups() method of the object returned by re.search.
 
 
-
    Regular expressions are extremely powerful, but they are not the correct solution for every problem.  You should learn enough
+
    Regular expressions are extremely powerful, but they are not the correct solution for every problem. You should learn enough
 about them to know when they are appropriate, when they will solve your problems, and when they will cause more problems than
 they solve.
 
    
@@ -5688,8 +5211,8 @@ they solve.
 
    Chapter 8. HTML Processing
    
 
    8.1. Diving in
    
 
    I often see questions on comp.lang.python like “How can I list all the [headers|images|links] in my HTML document?”  “How do I parse/translate/munge the text of my HTML document but leave the tags alone?”  “How can I add/remove/quote attributes of all my HTML tags at once?”  This chapter will answer all of these questions.
-
    Here is a complete, working Python program in two parts.  The first part, BaseHTMLProcessor.py, is a generic tool to help you process HTML files by walking through the tags and text blocks.  The second part, dialect.py, is an example of how to use BaseHTMLProcessor.py to translate the text of an HTML document but leave the tags alone.  Read the docstrings and comments to get an overview of what's going on.  Most of it will seem like black magic, because it's not obvious how
-any of these class methods ever get called.  Don't worry, all will be revealed in due time.
+
    Here is a complete, working Python program in two parts. The first part, BaseHTMLProcessor.py, is a generic tool to help you process HTML files by walking through the tags and text blocks. The second part, dialect.py, is an example of how to use BaseHTMLProcessor.py to translate the text of an HTML document but leave the tags alone. Read the docstrings and comments to get an overview of what's going on. Most of it will seem like black magic, because it's not obvious how
+any of these class methods ever get called. Don't worry, all will be revealed in due time.
 
    Example 8.1. BaseHTMLProcessor.py
    
 
    If you have not already done so, you can download this and other examples used in this book.
     from sgmllib import SGMLParser
@@ -5832,7 +5355,7 @@ class ChefDialectizer(Dialectizer):
             (r'V', r'F'),
             (r'w', r'w'),
             (r'W', r'W'),
-            (r'([a-z])[.]', r'\1.  Bork Bork Bork!'))
+            (r'([a-z])[.]', r'\1. Bork Bork Bork!'))
 
 class FuddDialectizer(Dialectizer):
     """convert HTML to Elmer Fudd-speak"""
@@ -5916,7 +5439,7 @@ def test(url):
 
 if __name__ == "__main__":
     test("http://diveintopython3.org/odbchelper_list.html")
    Example 8.3. Output of dialect.py
    
-
    Running this script will translate Section 3.2, “Introducing Lists” into mock Swedish Chef-speak (from The Muppets), mock Elmer Fudd-speak (from Bugs Bunny cartoons), and mock Middle English (loosely based on Chaucer's The Canterbury Tales).  If you look at the HTML source of the output pages, you'll see that all the HTML tags and attributes are untouched, but the text between the tags has been “translated” into the mock language.  If you look closer, you'll see that, in fact, only the titles and paragraphs were translated; the
+
    Running this script will translate Section 3.2, “Introducing Lists” into mock Swedish Chef-speak (from The Muppets), mock Elmer Fudd-speak (from Bugs Bunny cartoons), and mock Middle English (loosely based on Chaucer's The Canterbury Tales). If you look at the HTML source of the output pages, you'll see that all the HTML tags and attributes are untouched, but the text between the tags has been “translated” into the mock language. If you look closer, you'll see that, in fact, only the titles and paragraphs were translated; the
    code listings and screen examples were left untouched.
     <div class="abstract">
 <p>Lists awe <span class="application">Pydon</span>'s wowkhowse datatype.
@@ -5926,37 +5449,37 @@ in <span class="application">Powewbuiwdew</span>, bwace youwsewf fow
 <span class="application">Pydon</span> wists.</p>
 </div>
 
    8.2. Introducing sgmllib.py
    
-
    HTML processing is broken into three steps: breaking down the HTML into its constituent pieces, fiddling with the pieces, and reconstructing the pieces into HTML again.  The first step is done by sgmllib.py, a part of the standard Python library.
-
    The key to understanding this chapter is to realize that HTML is not just text, it is structured text.  The structure is derived from the more-or-less-hierarchical sequence of start tags
-and end tags.  Usually you don't work with HTML this way; you work with it textually in a text editor, or visually in a web browser or web authoring tool.  sgmllib.py presents HTML structurally.
-
    sgmllib.py contains one important class: SGMLParser.  SGMLParser parses HTML into useful pieces, like start tags and end tags.  As soon as it succeeds in breaking down some data into a useful piece,
-it calls a method on itself based on what it found.  In order to use the parser, you subclass the SGMLParser class and override these methods.  This is what I meant when I said that it presents HTML structurally: the structure of the HTML determines the sequence of method calls and the arguments passed to each method.
+
    HTML processing is broken into three steps: breaking down the HTML into its constituent pieces, fiddling with the pieces, and reconstructing the pieces into HTML again. The first step is done by sgmllib.py, a part of the standard Python library.
+
    The key to understanding this chapter is to realize that HTML is not just text, it is structured text. The structure is derived from the more-or-less-hierarchical sequence of start tags
+and end tags. Usually you don't work with HTML this way; you work with it textually in a text editor, or visually in a web browser or web authoring tool. sgmllib.py presents HTML structurally.
+
    sgmllib.py contains one important class: SGMLParser. SGMLParser parses HTML into useful pieces, like start tags and end tags. As soon as it succeeds in breaking down some data into a useful piece,
+it calls a method on itself based on what it found. In order to use the parser, you subclass the SGMLParser class and override these methods. This is what I meant when I said that it presents HTML structurally: the structure of the HTML determines the sequence of method calls and the arguments passed to each method.
 
    SGMLParser parses HTML into 8 kinds of data, and calls a separate method for each of them:
 
    
 
    
 
    Start tag
    
-
    An HTML tag that starts a block, like <html>, <head>, <body>, or <pre>, or a standalone tag like <br> or <img>.  When it finds a start tag tagname, SGMLParser will look for a method called start_tagname or do_tagname.  For instance, when it finds a <pre> tag, it will look for a start_pre or do_pre method.  If found, SGMLParser calls this method with a list of the tag's attributes; otherwise, it calls unknown_starttag with the tag name and list of attributes.
+
    An HTML tag that starts a block, like <html>, <head>, <body>, or <pre>, or a standalone tag like <br> or <img>. When it finds a start tag tagname, SGMLParser will look for a method called start_tagname or do_tagname. For instance, when it finds a <pre> tag, it will look for a start_pre or do_pre method. If found, SGMLParser calls this method with a list of the tag's attributes; otherwise, it calls unknown_starttag with the tag name and list of attributes.
 
    
 
    End tag
    
-
    An HTML tag that ends a block, like </html>, </head>, </body>, or </pre>.  When it finds an end tag, SGMLParser will look for a method called end_tagname.  If found, SGMLParser calls this method, otherwise it calls unknown_endtag with the tag name.
+
    An HTML tag that ends a block, like </html>, </head>, </body>, or </pre>. When it finds an end tag, SGMLParser will look for a method called end_tagname. If found, SGMLParser calls this method, otherwise it calls unknown_endtag with the tag name.
 
    
 
    Character reference
    
-
    An escaped character referenced by its decimal or hexadecimal equivalent, like &#160;.  When found, SGMLParser calls handle_charref with the text of the decimal or hexadecimal character equivalent.
+
    An escaped character referenced by its decimal or hexadecimal equivalent, like &#160;. When found, SGMLParser calls handle_charref with the text of the decimal or hexadecimal character equivalent.
 
    
 
    Entity reference
    
-
    An HTML entity, like &copy;.  When found, SGMLParser calls handle_entityref with the name of the HTML entity.
+
    An HTML entity, like &copy;. When found, SGMLParser calls handle_entityref with the name of the HTML entity.
 
    
 
    Comment
    
-
    An HTML comment, enclosed in <!-- ... -->.  When found, SGMLParser calls handle_comment with the body of the comment.
+
    An HTML comment, enclosed in <!-- ... -->. When found, SGMLParser calls handle_comment with the body of the comment.
 
    
 
    Processing instruction
    
-
    An HTML processing instruction, enclosed in <? ... >.  When found, SGMLParser calls handle_pi with the body of the processing instruction.
+
    An HTML processing instruction, enclosed in <? ... >. When found, SGMLParser calls handle_pi with the body of the processing instruction.
 
    
 
    Declaration
    
-
    An HTML declaration, such as a DOCTYPE, enclosed in <! ... >.  When found, SGMLParser calls handle_decl with the body of the declaration.
+
    An HTML declaration, such as a DOCTYPE, enclosed in <! ... >. When found, SGMLParser calls handle_decl with the body of the declaration.
 
    
 
    Text data
    
-
    A block of text.  Anything that doesn't fit into the other 7 categories.  When found, SGMLParser calls handle_data with the text.
+
    A block of text. Anything that doesn't fit into the other 7 categories. When found, SGMLParser calls handle_data with the text.
 
    
 
    
 
    
@@ -5964,22 +5487,22 @@ it calls a method on itself based on what it found.  In order to use the parser,
 
-
    Important
 
    
 
    Python 2.0 had a bug where SGMLParser would not recognize declarations at all (handle_decl would never be called), which meant that DOCTYPEs were silently ignored.  This is fixed in Python 2.1.
+Python 2.0 had a bug where SGMLParser would not recognize declarations at all (handle_decl would never be called), which meant that DOCTYPEs were silently ignored. This is fixed in Python 2.1.
 
 
    
 
    
-
    sgmllib.py comes with a test suite to illustrate this.  You can run sgmllib.py, passing the name of an HTML file on the command line, and it will print out the tags and other elements as it parses them.  It does this by subclassing
+
    sgmllib.py comes with a test suite to illustrate this. You can run sgmllib.py, passing the name of an HTML file on the command line, and it will print out the tags and other elements as it parses them. It does this by subclassing
 the SGMLParser class and defining unknown_starttag, unknown_endtag, handle_data and other methods which simply print their arguments.
-
    
 
    
 Tip
 
    
 
    In the ActivePython IDE on Windows, you can specify command line arguments in the “Run script” dialog.  Separate multiple arguments with spaces.
+In the ActivePython IDE on Windows, you can specify command line arguments in the “Run script” dialog. Separate multiple arguments with spaces.
 
 
    
 
    
 
    Example 8.4. Sample test of sgmllib.py
    
-
    Here is a snippet from the table of contents of the HTML version of this book.  Of course your paths may vary.  (If you haven't downloaded the HTML version of the book, you can do so at http://diveintopython3.org/.
    +
    Here is a snippet from the table of contents of the HTML version of this book. Of course your paths may vary. (If you haven't downloaded the HTML version of the book, you can do so at http://diveintopython3.org/.
     c:\python23\lib> type "c:\downloads\diveintopython3\html\toc\index.html"
 
 <!DOCTYPE html
@@ -6026,7 +5549,7 @@ data: '\n      '
 
    Along the way, you'll also learn about locals, globals, and dictionary-based string formatting.
 
    8.3. Extracting data from HTML documents
    
 
    To extract data from HTML documents, subclass the SGMLParser class and define methods for each tag or entity you want to capture.
-
    The first step to extracting data from an HTML document is getting some HTML.  If you have some HTML lying around on your hard drive, you can use file functions to read it, but the real fun begins when you get HTML from live web pages.
+
    The first step to extracting data from an HTML document is getting some HTML. If you have some HTML lying around on your hard drive, you can use file functions to read it, but the real fun begins when you get HTML from live web pages.
 
    Example 8.5. Introducing urllib
     >>> import urllib   1
 >>> sock = urllib.urlopen("http://diveintopython3.org/") 2
@@ -6052,19 +5575,19 @@ data: '\n      '
 
 1 
 
-The urllib module is part of the standard Python library.  It contains functions for getting information about and actually retrieving data from Internet-based URLs (mainly web pages).
+The urllib module is part of the standard Python library. It contains functions for getting information about and actually retrieving data from Internet-based URLs (mainly web pages).
 
 
 
 2 
 
-The simplest use of urllib is to retrieve the entire text of a web page using the urlopen function.  Opening a URL is similar to opening a file.  The return value of urlopen is a file-like object, which has some of the same methods as a file object.
+The simplest use of urllib is to retrieve the entire text of a web page using the urlopen function. Opening a URL is similar to opening a file. The return value of urlopen is a file-like object, which has some of the same methods as a file object.
 
 
 
 3 
 
-The simplest thing to do with the file-like object returned by urlopen is read, which reads the entire HTML of the web page into a single string.  The object also supports readlines, which reads the text line by line into a list.
+The simplest thing to do with the file-like object returned by urlopen is read, which reads the entire HTML of the web page into a single string. The object also supports readlines, which reads the text line by line into a list.
 
 
 
@@ -6097,14 +5620,14 @@ class URLLister(SGMLParser):
 
 1 
 
-reset is called by the __init__ method of SGMLParser, and it can also be called manually once an instance of the parser has been created.  So if you need to do any initialization,
+reset is called by the __init__ method of SGMLParser, and it can also be called manually once an instance of the parser has been created. So if you need to do any initialization,
             do it in reset, not in __init__, so that it will be re-initialized properly when someone re-uses a parser instance.
 
 
 
 2 
 
-start_a is called by SGMLParser whenever it finds an <a> tag.  The tag may contain an href attribute, and/or other attributes, like name or title.  The attrs parameter is a list of tuples, [(attribute, value), (attribute, value), ...].  Or it may be just an <a>, a valid (if useless) HTML tag, in which case attrs would be an empty list.
+start_a is called by SGMLParser whenever it finds an <a> tag. The tag may contain an href attribute, and/or other attributes, like name or title. The attrs parameter is a list of tuples, [(attribute, value), (attribute, value), ...]. Or it may be just an <a>, a valid (if useless) HTML tag, in which case attrs would be an empty list.
 
 
 
@@ -6159,20 +5682,20 @@ download/diveintopython3-common-5.0.zip
 
 3 
 
-You should close your parser object, too, but for a different reason.  You've read all the data and fed it to the parser, but the feed method isn't guaranteed to have actually processed all the HTML you give it; it may buffer it, waiting for more.  Be sure to call close to flush the buffer and force everything to be fully parsed.
+You should close your parser object, too, but for a different reason. You've read all the data and fed it to the parser, but the feed method isn't guaranteed to have actually processed all the HTML you give it; it may buffer it, waiting for more. Be sure to call close to flush the buffer and force everything to be fully parsed.
 
 
 
 4 
 
-Once the parser is closed, the parsing is complete, and parser.urls contains a list of all the linked URLs in the HTML document.  (Your output may look different, if the download links have been updated by the time you read this.)
+Once the parser is closed, the parsing is complete, and parser.urls contains a list of all the linked URLs in the HTML document. (Your output may look different, if the download links have been updated by the time you read this.)
 
 
 
 
    8.4. Introducing BaseHTMLProcessor.py
    
-
    SGMLParser doesn't produce anything by itself.  It parses and parses and parses, and it calls a method for each interesting thing it
-   finds, but the methods don't do anything.  SGMLParser is an HTML consumer: it takes HTML and breaks it down into small, structured pieces.  As you saw in the previous section, you can subclass SGMLParser to define classes that catch specific tags and produce useful things, like a list of all the links on a web page.  Now you'll
-   take this one step further by defining a class that catches everything SGMLParser throws at it and reconstructs the complete HTML document.  In technical terms, this class will be an HTML producer.
+
    SGMLParser doesn't produce anything by itself. It parses and parses and parses, and it calls a method for each interesting thing it
+   finds, but the methods don't do anything. SGMLParser is an HTML consumer: it takes HTML and breaks it down into small, structured pieces. As you saw in the previous section, you can subclass SGMLParser to define classes that catch specific tags and produce useful things, like a list of all the links on a web page. Now you'll
+   take this one step further by defining a class that catches everything SGMLParser throws at it and reconstructs the complete HTML document. In technical terms, this class will be an HTML producer.
 
    BaseHTMLProcessor subclasses SGMLParser and provides all 8 essential handler methods: unknown_starttag, unknown_endtag, handle_charref, handle_entityref, handle_comment, handle_pi, handle_decl, and handle_data.
 
    Example 8.8. Introducing BaseHTMLProcessor
     class BaseHTMLProcessor(SGMLParser):
@@ -6210,13 +5733,13 @@ class BaseHTMLProcessor(SGMLParser):
 
 1 
 
-reset, called by SGMLParser.__init__, initializes self.pieces as an empty list before calling the ancestor method.  self.pieces is a data attribute which will hold the pieces of the HTML document you're constructing.  Each handler method will reconstruct the HTML that SGMLParser parsed, and each method will append that string to self.pieces.  Note that self.pieces is a list.  You might be tempted to define it as a string and just keep appending each piece to it.  That would work, but
+reset, called by SGMLParser.__init__, initializes self.pieces as an empty list before calling the ancestor method. self.pieces is a data attribute which will hold the pieces of the HTML document you're constructing. Each handler method will reconstruct the HTML that SGMLParser parsed, and each method will append that string to self.pieces. Note that self.pieces is a list. You might be tempted to define it as a string and just keep appending each piece to it. That would work, but
 Python is much more efficient at dealing with lists.[2]
 
 
 2 
 
-Since BaseHTMLProcessor does not define any methods for specific tags (like the start_a method in URLLister), SGMLParser will call unknown_starttag for every start tag.  This method takes the tag (tag) and the list of attribute name/value pairs (attrs), reconstructs the original HTML, and appends it to self.pieces.  The string formatting here is a little strange; you'll untangle that (and also the odd-looking locals function) later in this chapter.
+Since BaseHTMLProcessor does not define any methods for specific tags (like the start_a method in URLLister), SGMLParser will call unknown_starttag for every start tag. This method takes the tag (tag) and the list of attribute name/value pairs (attrs), reconstructs the original HTML, and appends it to self.pieces. The string formatting here is a little strange; you'll untangle that (and also the odd-looking locals function) later in this chapter.
 
 
 
@@ -6228,15 +5751,15 @@ Python is much more efficient at dealing with lists.[
 4 
 
-When SGMLParser finds a character reference, it calls handle_charref with the bare reference.  If the HTML document contains the reference &#160;, ref will be 160.  Reconstructing the original complete character reference just involves wrapping ref in &#...; characters.
+When SGMLParser finds a character reference, it calls handle_charref with the bare reference. If the HTML document contains the reference &#160;, ref will be 160. Reconstructing the original complete character reference just involves wrapping ref in &#...; characters.
 
 
 
 5 
 
-Entity references are similar to character references, but without the hash mark.  Reconstructing the original entity reference
-            requires wrapping ref in &...; characters.  (Actually, as an erudite reader pointed out to me, it's slightly more complicated than this.  Only certain standard
-HTML entites end in a semicolon; other similar-looking entities do not.  Luckily for us, the set of standard HTML entities is defined in a dictionary in a Python module called htmlentitydefs.  Hence the extra if statement.)
+Entity references are similar to character references, but without the hash mark. Reconstructing the original entity reference
+            requires wrapping ref in &...; characters. (Actually, as an erudite reader pointed out to me, it's slightly more complicated than this. Only certain standard
+HTML entites end in a semicolon; other similar-looking entities do not. Luckily for us, the set of standard HTML entities is defined in a dictionary in a Python module called htmlentitydefs. Hence the extra if statement.)
 
 
 
@@ -6263,7 +5786,7 @@ Python is much more efficient at dealing with lists.[Important
 
 
-The HTML specification requires that all non-HTML (like client-side JavaScript) must be enclosed in HTML comments, but not all web pages do this properly (and all modern web browsers are forgiving if they don't).  BaseHTMLProcessor is not forgiving; if script is improperly embedded, it will be parsed as if it were HTML.  For instance, if the script contains less-than and equals signs, SGMLParser may incorrectly think that it has found tags and attributes.  SGMLParser always converts tags and attribute names to lowercase, which may break the script, and BaseHTMLProcessor always encloses attribute values in double quotes (even if the original HTML document used single quotes or no quotes), which will certainly break the script.  Always protect your client-side script
+The HTML specification requires that all non-HTML (like client-side JavaScript) must be enclosed in HTML comments, but not all web pages do this properly (and all modern web browsers are forgiving if they don't). BaseHTMLProcessor is not forgiving; if script is improperly embedded, it will be parsed as if it were HTML. For instance, if the script contains less-than and equals signs, SGMLParser may incorrectly think that it has found tags and attributes. SGMLParser always converts tags and attribute names to lowercase, which may break the script, and BaseHTMLProcessor always encloses attribute values in double quotes (even if the original HTML document used single quotes or no quotes), which will certainly break the script. Always protect your client-side script
       within HTML comments.
 
 
@@ -6276,7 +5799,7 @@ Python is much more efficient at dealing with lists.[
 1 
 
-This is the one method in BaseHTMLProcessor that is never called by the ancestor SGMLParser.  Since the other handler methods store their reconstructed HTML in self.pieces, this function is needed to join all those pieces into one string.  As noted before, Python is great at lists and mediocre at strings, so you only create the complete string when somebody explicitly asks for it.
+This is the one method in BaseHTMLProcessor that is never called by the ancestor SGMLParser. Since the other handler methods store their reconstructed HTML in self.pieces, this function is needed to join all those pieces into one string. As noted before, Python is great at lists and mediocre at strings, so you only create the complete string when somebody explicitly asks for it.
 
 
 
@@ -6294,28 +5817,28 @@ Python is much more efficient at dealing with lists.[
 
    8.5. locals and globals
    
-
    Let's digress from HTML processing for a minute and talk about how Python handles variables.  Python has two built-in functions, locals and globals, which provide dictionary-based access to local and global variables.
+
    Let's digress from HTML processing for a minute and talk about how Python handles variables. Python has two built-in functions, locals and globals, which provide dictionary-based access to local and global variables.
 
    Remember locals?  You first saw it here:
 
         def unknown_starttag(self, tag, attrs):
         strattrs = "".join([' %s="%s"' % (key, value) for key, value in attrs])
         self.pieces.append("<%(tag)s%(strattrs)s>" % locals())
-
    No, wait, you can't learn about locals yet.  First, you need to learn about namespaces.  This is dry stuff, but it's important, so pay attention.
-
    Python uses what are called namespaces to keep track of variables.  A namespace is just like a dictionary where the keys are names
-of variables and the dictionary values are the values of those variables.  In fact, you can access a namespace as a Python dictionary, as you'll see in a minute.
-
    At any particular point in a Python program, there are several namespaces available.  Each function has its own namespace, called the local namespace, which
-keeps track of the function's variables, including function arguments and locally defined variables.  Each module has its
+
    No, wait, you can't learn about locals yet. First, you need to learn about namespaces. This is dry stuff, but it's important, so pay attention.
+
    Python uses what are called namespaces to keep track of variables. A namespace is just like a dictionary where the keys are names
+of variables and the dictionary values are the values of those variables. In fact, you can access a namespace as a Python dictionary, as you'll see in a minute.
+
    At any particular point in a Python program, there are several namespaces available. Each function has its own namespace, called the local namespace, which
+keeps track of the function's variables, including function arguments and locally defined variables. Each module has its
 own namespace, called the global namespace, which keeps track of the module's variables, including functions, classes, any
-other imported modules, and module-level variables and constants.  And there is the built-in namespace, accessible from any
+other imported modules, and module-level variables and constants. And there is the built-in namespace, accessible from any
 module, which holds built-in functions and exceptions.
 
    When a line of code asks for the value of a variable x, Python will search for that variable in all the available namespaces, in order:
 
    
 
      
-
    1. local namespace - specific to the current function or class method.  If the function defines a local variable x, or has an argument x, Python will use this and stop searching.
+
    2. local namespace - specific to the current function or class method. If the function defines a local variable x, or has an argument x, Python will use this and stop searching.
 
-
    3. global namespace - specific to the current module.  If the module has defined a variable, function, or class called x, Python will use that and stop searching.
+
    4. global namespace - specific to the current module. If the module has defined a variable, function, or class called x, Python will use that and stop searching.
 
-
    5. built-in namespace - global to all modules.  As a last resort, Python will assume that x is the name of built-in function or variable.
+
    6. built-in namespace - global to all modules. As a last resort, Python will assume that x is the name of built-in function or variable.
 
 
    
 
    If Python doesn't find x in any of these namespaces, it gives up and raises a NameError with the message There is no variable named 'x', which you saw back in Example 3.18, “Referencing an Unbound Variable”, but you didn't appreciate how much work Python was doing before giving you that error.
@@ -6323,15 +5846,15 @@ module, which holds built-in functions and exceptions.
 
-
    Important
 
    
 
    Python 2.2 introduced a subtle but important change that affects the namespace search order: nested scopes.  In versions of Python prior to 2.2, when you reference a variable within a nested function or lambda function, Python will search for that variable in the current (nested or lambda) function's namespace, then in the module's namespace.  Python 2.2 will search for the variable in the current (nested or lambda) function's namespace, then in the parent function's namespace, then in the module's namespace.  Python 2.1 can work either way; by default, it works like Python 2.0, but you can add the following line of code at the top of your module to make your module work like Python 2.2:
    +
    		Python 2.2 introduced a subtle but important change that affects the namespace search order: nested scopes. In versions of Python prior to 2.2, when you reference a variable within a nested function or lambda function, Python will search for that variable in the current (nested or lambda) function's namespace, then in the module's namespace. Python 2.2 will search for the variable in the current (nested or lambda) function's namespace, then in the parent function's namespace, then in the module's namespace. Python 2.1 can work either way; by default, it works like Python 2.0, but you can add the following line of code at the top of your module to make your module work like Python 2.2:
     from __future__ import nested_scopes
    		
 
    
 
    
-
    Are you confused yet?  Don't despair!  This is really cool, I promise.  Like many things in Python, namespaces are directly accessible at run-time.  How?  Well, the local namespace is accessible via the built-in locals function, and the global (module level) namespace is accessible via the built-in globals function.
+
    Are you confused yet?  Don't despair!  This is really cool, I promise. Like many things in Python, namespaces are directly accessible at run-time. How?  Well, the local namespace is accessible via the built-in locals function, and the global (module level) namespace is accessible via the built-in globals function.
 
    Example 8.10. Introducing locals
    >>> def foo(arg): 1
-...     x = 1
-...     print locals()
-...     
+...    x = 1
+...    print locals()
+...    
 >>> foo(7)        2
 {'arg': 7, 'x': 1}
 >>> foo('bar')    3
@@ -6346,22 +5869,22 @@ from __future__ import nested_scopes
    
 
 2 
 
-locals returns a dictionary of name/value pairs.  The keys of this dictionary are the names of the variables as strings; the values
-            of the dictionary are the actual values of the variables.  So calling foo with 7 prints the dictionary containing the function's two local variables: arg (7) and x (1).
+locals returns a dictionary of name/value pairs. The keys of this dictionary are the names of the variables as strings; the values
+            of the dictionary are the actual values of the variables. So calling foo with 7 prints the dictionary containing the function's two local variables: arg (7) and x (1).
 
 
 
 3 
 
-Remember, Python has dynamic typing, so you could just as easily pass a string in for arg; the function (and the call to locals) would still work just as well.  locals works with all variables of all datatypes.
+Remember, Python has dynamic typing, so you could just as easily pass a string in for arg; the function (and the call to locals) would still work just as well. locals works with all variables of all datatypes.
 
 
 
-
    What locals does for the local (function) namespace, globals does for the global (module) namespace.  globals is more exciting, though, because a module's namespace is more exciting.[3]  Not only does the module's namespace include module-level variables and constants, it includes all the functions and classes
-defined in the module.  Plus, it includes anything that was imported into the module.
+
    What locals does for the local (function) namespace, globals does for the global (module) namespace. globals is more exciting, though, because a module's namespace is more exciting.[3]  Not only does the module's namespace include module-level variables and constants, it includes all the functions and classes
+defined in the module. Plus, it includes anything that was imported into the module.
 
    Remember the difference between from module import and import module?  With import module, the module itself is imported, but it retains its own namespace, which is why you need to use the module name to access
-any of its functions or attributes: module.function.  But with from module import, you're actually importing specific functions and attributes from another module into your own namespace, which is why you
-access them directly without referencing the original module they came from.  With the globals function, you can actually see this happen.
+any of its functions or attributes: module.function. But with from module import, you're actually importing specific functions and attributes from another module into your own namespace, which is why you
+access them directly without referencing the original module they came from. With the globals function, you can actually see this happen.
 
    Example 8.11. Introducing globals
    
 
    Look at the following block of code at the bottom of BaseHTMLProcessor.py:
     if __name__ == "__main__":
@@ -6371,7 +5894,7 @@ if __name__ == "__main__":
 
 1 
 
-Just so you don't get intimidated, remember that you've seen all this before.  The globals function returns a dictionary, and you're iterating through the dictionary using the items method and multi-variable assignment.  The only thing new here is the globals function.
+Just so you don't get intimidated, remember that you've seen all this before. The globals function returns a dictionary, and you're iterating through the dictionary using the items method and multi-variable assignment. The only thing new here is the globals function.
 
 
 
@@ -6386,25 +5909,25 @@ __name__ = __main__          1 
 
-SGMLParser was imported from sgmllib, using from module import.  That means that it was imported directly into the module's namespace, and here it is.
+SGMLParser was imported from sgmllib, using from module import. That means that it was imported directly into the module's namespace, and here it is.
 
 
 
 2 
 
-Contrast this with htmlentitydefs, which was imported using import.  That means that the htmlentitydefs module itself is in the namespace, but the entitydefs variable defined within htmlentitydefs is not.
+Contrast this with htmlentitydefs, which was imported using import. That means that the htmlentitydefs module itself is in the namespace, but the entitydefs variable defined within htmlentitydefs is not.
 
 
 
 3 
 
-This module only defines one class, BaseHTMLProcessor, and here it is.  Note that the value here is the class itself, not a specific instance of the class.
+This module only defines one class, BaseHTMLProcessor, and here it is. Note that the value here is the class itself, not a specific instance of the class.
 
 
 
 4 
 
-Remember the if __name__ trick?  When running a module (as opposed to importing it from another module), the built-in __name__ attribute is a special value, __main__.  Since you ran this module as a script from the command line, __name__ is __main__, which is why the little test code to print the globals got executed.
+Remember the if __name__ trick?  When running a module (as opposed to importing it from another module), the built-in __name__ attribute is a special value, __main__. Since you ran this module as a script from the command line, __name__ is __main__, which is why the little test code to print the globals got executed.
 
 
 
@@ -6413,12 +5936,12 @@ __name__ = __main__          Note
 
 
-Using the locals and globals functions, you can get the value of arbitrary variables dynamically, providing the variable name as a string.  This mirrors
+Using the locals and globals functions, you can get the value of arbitrary variables dynamically, providing the variable name as a string. This mirrors
       the functionality of the getattr function, which allows you to access arbitrary functions dynamically by providing the function name as a string.
 
 
 
-
    There is one other important difference between the locals and globals functions, which you should learn now before it bites you.  It will bite you anyway, but at least then you'll remember learning
+
    There is one other important difference between the locals and globals functions, which you should learn now before it bites you. It will bite you anyway, but at least then you'll remember learning
 it.
 
    Example 8.12. locals is read-only, globals is not
     def foo(arg):
@@ -6437,14 +5960,14 @@ print "z=",z          
 1 
 
-Since foo is called with 3, this will print {'arg': 3, 'x': 1}.  This should not be a surprise.
+Since foo is called with 3, this will print {'arg': 3, 'x': 1}. This should not be a surprise.
 
 
 
 2 
 
-locals is a function that returns a dictionary, and here you are setting a value in that dictionary.  You might think that this
-            would change the value of the local variable x to 2, but it doesn't.  locals does not actually return the local namespace, it returns a copy.  So changing it does nothing to the value of the variables
+locals is a function that returns a dictionary, and here you are setting a value in that dictionary. You might think that this
+            would change the value of the local variable x to 2, but it doesn't. locals does not actually return the local namespace, it returns a copy. So changing it does nothing to the value of the variables
             in the local namespace.
 
 
@@ -6457,7 +5980,7 @@ print "z=",z          
 4 
 
-After being burned by locals, you might think that this wouldn't change the value of z, but it does.  Due to internal differences in how Python is implemented (which I'd rather not go into, since I don't fully understand them myself), globals returns the actual global namespace, not a copy: the exact opposite behavior of locals.  So any changes to the dictionary returned by globals directly affect your global variables.
+After being burned by locals, you might think that this wouldn't change the value of z, but it does. Due to internal differences in how Python is implemented (which I'd rather not go into, since I don't fully understand them myself), globals returns the actual global namespace, not a copy: the exact opposite behavior of locals. So any changes to the dictionary returned by globals directly affect your global variables.
 
 
 
@@ -6468,9 +5991,9 @@ print "z=",z          
 
 
    8.6. Dictionary-based string formatting
    
-
    Why did you learn about locals and globals?  So you can learn about dictionary-based string formatting.  As you recall, regular string formatting provides an easy way to insert values into strings.  Values are listed in a tuple and inserted in order into the string in
-place of each formatting marker.  While this is efficient, it is not always the easiest code to read, especially when multiple
-values are being inserted.  You can't simply scan through the string in one pass and understand what the result will be; you're
+
    Why did you learn about locals and globals?  So you can learn about dictionary-based string formatting. As you recall, regular string formatting provides an easy way to insert values into strings. Values are listed in a tuple and inserted in order into the string in
+place of each formatting marker. While this is efficient, it is not always the easiest code to read, especially when multiple
+values are being inserted. You can't simply scan through the string in one pass and understand what the result will be; you're
 constantly switching between reading the string and reading the tuple of values.
 
    There is an alternative form of string formatting that uses dictionaries instead of tuples of values.
 
    Example 8.13. Introducing dictionary-based string formatting
    @@ -6485,13 +6008,13 @@ constantly switching between reading the string and reading the tuple of values.
 
 1 
 
-Instead of a tuple of explicit values, this form of string formatting uses a dictionary, params.  And instead of a simple %s marker in the string, the marker contains a name in parentheses.  This name is used as a key in the params dictionary and subsitutes the corresponding value, secret, in place of the %(pwd)s marker.
+Instead of a tuple of explicit values, this form of string formatting uses a dictionary, params. And instead of a simple %s marker in the string, the marker contains a name in parentheses. This name is used as a key in the params dictionary and subsitutes the corresponding value, secret, in place of the %(pwd)s marker.
 
 
 
 2 
 
-Dictionary-based string formatting works with any number of named keys.  Each key must exist in the given dictionary, or the
+Dictionary-based string formatting works with any number of named keys. Each key must exist in the given dictionary, or the
             formatting will fail with a KeyError.
 
 
@@ -6503,7 +6026,7 @@ constantly switching between reading the string and reading the tuple of values.
 
 
    So why would you use dictionary-based string formatting?  Well, it does seem like overkill to set up a dictionary of keys
 and values simply to do string formatting in the next line; it's really most useful when you happen to have a dictionary of
-meaningful keys and values already.  Like locals.
+meaningful keys and values already. Like locals.
 
    Example 8.14. Dictionary-based string formatting in BaseHTMLProcessor.py
         def handle_comment(self, text):        
         self.pieces.append("<!--%(text)s-->" % locals()) 1
@@ -6512,8 +6035,8 @@ meaningful keys and values already.  Like 1 
 
-Using the built-in locals function is the most common use of dictionary-based string formatting.  It means that you can use the names of local variables
-            within your string (in this case, text, which was passed to the class method as an argument) and each named variable will be replaced by its value.  If text is 'Begin page footer', the string formatting "<!--%(text)s-->" % locals() will resolve to the string '<!--Begin page footer-->'.
+Using the built-in locals function is the most common use of dictionary-based string formatting. It means that you can use the names of local variables
+            within your string (in this case, text, which was passed to the class method as an argument) and each named variable will be replaced by its value. If text is 'Begin page footer', the string formatting "<!--%(text)s-->" % locals() will resolve to the string '<!--Begin page footer-->'.
 
 
 
@@ -6526,14 +6049,14 @@ meaningful keys and values already.  Like 1 
 
-When this method is called, attrs is a list of key/value tuples, just like the items of a dictionary, which means you can use multi-variable assignment to iterate through it.  This should be a familiar pattern by now, but there's a lot going on here, so let's break it down:
+When this method is called, attrs is a list of key/value tuples, just like the items of a dictionary, which means you can use multi-variable assignment to iterate through it. This should be a familiar pattern by now, but there's a lot going on here, so let's break it down:
 
    
 
      
 
    1. Suppose attrs is [('href', 'index.html'), ('title', 'Go to home page')].
 
 
    2. In the first round of the list comprehension, key will get 'href', and value will get 'index.html'.
 
-
    3. The string formatting ' %s="%s"' % (key, value) will resolve to ' href="index.html"'.  This string becomes the first element of the list comprehension's return value.
+
    4. The string formatting ' %s="%s"' % (key, value) will resolve to ' href="index.html"'. This string becomes the first element of the list comprehension's return value.
 
 
    5. In the second round, key will get 'title', and value will get 'Go to home page'.
 
@@ -6547,7 +6070,7 @@ meaningful keys and values already.  Like 2 
 
-Now, using dictionary-based string formatting, you insert the value of tag and strattrs into a string.  So if tag is 'a', the final result would be '<a href="index.html" title="Go to home page">', and that is what gets appended to self.pieces.
+Now, using dictionary-based string formatting, you insert the value of tag and strattrs into a string. So if tag is 'a', the final result would be '<a href="index.html" title="Go to home page">', and that is what gets appended to self.pieces.
 
 
 
@@ -6556,30 +6079,30 @@ meaningful keys and values already.  Like Important
 
 
-Using dictionary-based string formatting with locals is a convenient way of making complex string formatting expressions more readable, but it comes with a price.  There is a
+Using dictionary-based string formatting with locals is a convenient way of making complex string formatting expressions more readable, but it comes with a price. There is a
       slight performance hit in making the call to locals, since locals builds a copy of the local namespace.
 
 
 
 
      8.7. Quoting attribute values
      
-
      A common question on comp.lang.python is “I have a bunch of HTML documents with unquoted attribute values, and I want to properly quote them all.  How can I do this?”[4]  (This is generally precipitated by a project manager who has found the HTML-is-a-standard religion joining a large project and proclaiming that all pages must validate against an HTML validator.  Unquoted attribute values are a common violation of the HTML standard.)  Whatever the reason, unquoted attribute values are easy to fix by feeding HTML through BaseHTMLProcessor.
-
      BaseHTMLProcessor consumes HTML (since it's descended from SGMLParser) and produces equivalent HTML, but the HTML output is not identical to the input.  Tags and attribute names will end up in lowercase, even if they started in uppercase
+
      A common question on comp.lang.python is “I have a bunch of HTML documents with unquoted attribute values, and I want to properly quote them all. How can I do this?”[4]  (This is generally precipitated by a project manager who has found the HTML-is-a-standard religion joining a large project and proclaiming that all pages must validate against an HTML validator. Unquoted attribute values are a common violation of the HTML standard.)  Whatever the reason, unquoted attribute values are easy to fix by feeding HTML through BaseHTMLProcessor.
+
      BaseHTMLProcessor consumes HTML (since it's descended from SGMLParser) and produces equivalent HTML, but the HTML output is not identical to the input. Tags and attribute names will end up in lowercase, even if they started in uppercase
 or mixed case, and attribute values will be enclosed in double quotes, even if they started in single quotes or with no quotes
-at all.  It is this last side effect that you can take advantage of.
+at all. It is this last side effect that you can take advantage of.
 
      Example 8.16. Quoting attribute values
       >>> htmlSource = """        1
-...     <html>
-...     <head>
-...     <title>Test page</title>
-...     </head>
-...     <body>
-...     <ul>
-...     <li><a href=index.html>Home</a></li>
-...     <li><a href=toc.html>Table of contents</a></li>
-...     <li><a href=history.html>Revision history</a></li>
-...     </body>
-...     </html>
-...     """
+...    <html>
+...    <head>
+...    <title>Test page</title>
+...    </head>
+...    <body>
+...    <ul>
+...    <li><a href=index.html>Home</a></li>
+...    <li><a href=toc.html>Table of contents</a></li>
+...    <li><a href=history.html>Revision history</a></li>
+...    </body>
+...    </html>
+...    """
 >>> from BaseHTMLProcessor import BaseHTMLProcessor
 >>> parser = BaseHTMLProcessor()
 >>> parser.feed(htmlSource) 2
@@ -6599,7 +6122,7 @@ at all.  It is this last side effect that you can take advantage of.
 
 1 
 
-Note that the attribute values of the href attributes in the <a> tags are not properly quoted.  (Also note that you're using triple quotes for something other than a docstring.  And directly in the IDE, no less.  They're very useful.)
+Note that the attribute values of the href attributes in the <a> tags are not properly quoted. (Also note that you're using triple quotes for something other than a docstring. And directly in the IDE, no less. They're very useful.)
 
 
 
@@ -6610,13 +6133,13 @@ at all.  It is this last side effect that you can take advantage of.
 
 3 
 
-Using the output function defined in BaseHTMLProcessor, you get the output as a single string, complete with quoted attribute values.  While this may seem anti-climactic, think
+Using the output function defined in BaseHTMLProcessor, you get the output as a single string, complete with quoted attribute values. While this may seem anti-climactic, think
             about how much has actually happened here: SGMLParser parsed the entire HTML document, breaking it down into tags, refs, data, and so forth; BaseHTMLProcessor used those elements to reconstruct pieces of HTML (which are still stored in parser.pieces, if you want to see them); finally, you called parser.output, which joined all the pieces of HTML into one string.
 
 
 
 
      8.8. Introducing dialect.py
      
-
      Dialectizer is a simple (and silly) descendant of BaseHTMLProcessor.  It runs blocks of text through a series of substitutions, but it makes sure that anything within a <pre>...</pre> block passes through unaltered.
+
      Dialectizer is a simple (and silly) descendant of BaseHTMLProcessor. It runs blocks of text through a series of substitutions, but it makes sure that anything within a <pre>...</pre> block passes through unaltered.
 
      To handle the <pre> blocks, you define two methods in Dialectizer: start_pre and end_pre.
 
      Example 8.17. Handling specific tags
           def start_pre(self, attrs):             1
@@ -6630,25 +6153,25 @@ at all.  It is this last side effect that you can take advantage of.
 
 1 
 
-start_pre is called every time SGMLParser finds a <pre> tag in the HTML source.  (In a minute, you'll see exactly how this happens.)  The method takes a single parameter, attrs, which contains the attributes of the tag (if any).  attrs is a list of key/value tuples, just like unknown_starttag takes.
+start_pre is called every time SGMLParser finds a <pre> tag in the HTML source. (In a minute, you'll see exactly how this happens.)  The method takes a single parameter, attrs, which contains the attributes of the tag (if any). attrs is a list of key/value tuples, just like unknown_starttag takes.
 
 
 
 2 
 
-In the reset method, you initialize a data attribute that serves as a counter for <pre> tags.  Every time you hit a <pre> tag, you increment the counter; every time you hit a </pre> tag, you'll decrement the counter.  (You could just use this as a flag and set it to 1 and reset it to 0, but it's just as easy to do it this way, and this handles the odd (but possible) case of nested <pre> tags.)  In a minute, you'll see how this counter is put to good use.
+In the reset method, you initialize a data attribute that serves as a counter for <pre> tags. Every time you hit a <pre> tag, you increment the counter; every time you hit a </pre> tag, you'll decrement the counter. (You could just use this as a flag and set it to 1 and reset it to 0, but it's just as easy to do it this way, and this handles the odd (but possible) case of nested <pre> tags.)  In a minute, you'll see how this counter is put to good use.
 
 
 
 3 
 
-That's it, that's the only special processing you do for <pre> tags.  Now you pass the list of attributes along to unknown_starttag so it can do the default processing.
+That's it, that's the only special processing you do for <pre> tags. Now you pass the list of attributes along to unknown_starttag so it can do the default processing.
 
 
 
 4 
 
-end_pre is called every time SGMLParser finds a </pre> tag.  Since end tags can not contain attributes, the method takes no parameters.
+end_pre is called every time SGMLParser finds a </pre> tag. Since end tags can not contain attributes, the method takes no parameters.
 
 
 
@@ -6663,7 +6186,7 @@ at all.  It is this last side effect that you can take advantage of.
 
 
 
-
      At this point, it's worth digging a little further into SGMLParser.  I've claimed repeatedly (and you've taken it on faith so far) that SGMLParser looks for and calls specific methods for each tag, if they exist.  For instance, you just saw the definition of start_pre and end_pre to handle <pre> and </pre>.  But how does this happen?  Well, it's not magic, it's just good Python coding.
+
      At this point, it's worth digging a little further into SGMLParser. I've claimed repeatedly (and you've taken it on faith so far) that SGMLParser looks for and calls specific methods for each tag, if they exist. For instance, you just saw the definition of start_pre and end_pre to handle <pre> and </pre>. But how does this happen?  Well, it's not magic, it's just good Python coding.
 
      Example 8.18. SGMLParser
           def finish_starttag(self, tag, attrs):               1
         try:        
@@ -6688,14 +6211,14 @@ at all.  It is this last side effect that you can take advantage of.
 
 1 
 
-At this point, SGMLParser has already found a start tag and parsed the attribute list.  The only thing left to do is figure out whether there is a
+At this point, SGMLParser has already found a start tag and parsed the attribute list. The only thing left to do is figure out whether there is a
             specific handler method for this tag, or whether you should fall back on the default method (unknown_starttag).
 
 
 
 2 
 
-The “magic” of SGMLParser is nothing more than your old friend, getattr.  What you may not have realized before is that getattr will find methods defined in descendants of an object as well as the object itself.  Here the object is self, the current instance.  So if tag is 'pre', this call to getattr will look for a start_pre method on the current instance, which is an instance of the Dialectizer class.
+The “magic” of SGMLParser is nothing more than your old friend, getattr. What you may not have realized before is that getattr will find methods defined in descendants of an object as well as the object itself. Here the object is self, the current instance. So if tag is 'pre', this call to getattr will look for a start_pre method on the current instance, which is an instance of the Dialectizer class.
 
 
 
@@ -6708,19 +6231,19 @@ at all.  It is this last side effect that you can take advantage of.
 
 4 
 
-Since you didn't find a start_xxx method, you'll also look for a do_xxx method before giving up.  This alternate naming scheme is generally used for standalone tags, like <br>, which have no corresponding end tag.  But you can use either naming scheme; as you can see, SGMLParser tries both for every tag.  (You shouldn't define both a start_xxx and do_xxx handler method for the same tag, though; only the start_xxx method will get called.)
+Since you didn't find a start_xxx method, you'll also look for a do_xxx method before giving up. This alternate naming scheme is generally used for standalone tags, like <br>, which have no corresponding end tag. But you can use either naming scheme; as you can see, SGMLParser tries both for every tag. (You shouldn't define both a start_xxx and do_xxx handler method for the same tag, though; only the start_xxx method will get called.)
 
 
 
 5 
 
-Another AttributeError, which means that the call to getattr failed with do_xxx.  Since you found neither a start_xxx nor a do_xxx method for this tag, you catch the exception and fall back on the default method, unknown_starttag.
+Another AttributeError, which means that the call to getattr failed with do_xxx. Since you found neither a start_xxx nor a do_xxx method for this tag, you catch the exception and fall back on the default method, unknown_starttag.
 
 
 
 6 
 
-Remember, try...except blocks can have an else clause, which is called if no exception is raised during the try...except block.  Logically, that means that you did find a do_xxx method for this tag, so you're going to call it.
+Remember, try...except blocks can have an else clause, which is called if no exception is raised during the try...except block. Logically, that means that you did find a do_xxx method for this tag, so you're going to call it.
 
 
 
@@ -6728,22 +6251,22 @@ at all.  It is this last side effect that you can take advantage of.
 
 By the way, don't worry about these different return values; in theory they mean something, but they're never actually used.
              Don't worry about the self.stack.append(tag) either; SGMLParser keeps track internally of whether your start tags are balanced by appropriate end tags, but it doesn't do anything with this
-            information either.  In theory, you could use this module to validate that your tags were fully balanced, but it's probably
-            not worth it, and it's beyond the scope of this chapter.  You have better things to worry about right now.
+            information either. In theory, you could use this module to validate that your tags were fully balanced, but it's probably
+            not worth it, and it's beyond the scope of this chapter. You have better things to worry about right now.
 
 
 
 8 
 
-start_xxx and do_xxx methods are not called directly; the tag, method, and attributes are passed to this function, handle_starttag, so that descendants can override it and change the way all start tags are dispatched.  You don't need that level of control, so you just let this method do its thing, which is to call
-            the method (start_xxx or do_xxx) with the list of attributes.  Remember, method is a function, returned from getattr, and functions are objects.  (I know you're getting tired of hearing it, and I promise I'll stop saying it as soon as I run
+start_xxx and do_xxx methods are not called directly; the tag, method, and attributes are passed to this function, handle_starttag, so that descendants can override it and change the way all start tags are dispatched. You don't need that level of control, so you just let this method do its thing, which is to call
+            the method (start_xxx or do_xxx) with the list of attributes. Remember, method is a function, returned from getattr, and functions are objects. (I know you're getting tired of hearing it, and I promise I'll stop saying it as soon as I run
             out of ways to use it to my advantage.)  Here, the function object is passed into this dispatch method as an argument, and
-            this method turns around and calls the function.  At this point, you don't need to know what the function is, what it's named,
+            this method turns around and calls the function. At this point, you don't need to know what the function is, what it's named,
             or where it's defined; the only thing you need to know about the function is that it is called with one argument, attrs.
 
 
 
-
      Now back to our regularly scheduled program: Dialectizer.  When you left, you were in the process of defining specific handler methods for <pre> and </pre> tags.  There's only one thing left to do, and that is to process text blocks with the pre-defined substitutions.  For that,
+
      Now back to our regularly scheduled program: Dialectizer. When you left, you were in the process of defining specific handler methods for <pre> and </pre> tags. There's only one thing left to do, and that is to process text blocks with the pre-defined substitutions. For that,
 you need to override the handle_data method.
 
      Example 8.19. Overriding the handle_data method
           def handle_data(self, text):     1
@@ -6758,16 +6281,16 @@ you need to override the handle_data method.
 
 2 
 
-In the ancestor BaseHTMLProcessor, the handle_data method simply appended the text to the output buffer, self.pieces.  Here the logic is only slightly more complicated.  If you're in the middle of a <pre>...</pre> block, self.verbatim will be some value greater than 0, and you want to put the text in the output buffer unaltered.  Otherwise, you will call a separate method to process the
-            substitutions, then put the result of that into the output buffer.  In Python, this is a one-liner, using the and-or trick.
+In the ancestor BaseHTMLProcessor, the handle_data method simply appended the text to the output buffer, self.pieces. Here the logic is only slightly more complicated. If you're in the middle of a <pre>...</pre> block, self.verbatim will be some value greater than 0, and you want to put the text in the output buffer unaltered. Otherwise, you will call a separate method to process the
+            substitutions, then put the result of that into the output buffer. In Python, this is a one-liner, using the and-or trick.
 
 
 
-
      You're close to completely understanding Dialectizer.  The only missing link is the nature of the text substitutions themselves.  If you know any Perl, you know that when complex text substitutions are required, the only real solution is regular expressions.  The classes
-later in dialect.py define a series of regular expressions that operate on the text between the HTML tags.  But you just had a whole chapter on regular expressions.  You don't really want to slog through regular expressions again, do you?  God knows I don't.  I think you've learned enough
+
      You're close to completely understanding Dialectizer. The only missing link is the nature of the text substitutions themselves. If you know any Perl, you know that when complex text substitutions are required, the only real solution is regular expressions. The classes
+later in dialect.py define a series of regular expressions that operate on the text between the HTML tags. But you just had a whole chapter on regular expressions. You don't really want to slog through regular expressions again, do you?  God knows I don't. I think you've learned enough
 for one chapter.
 
      8.9. Putting it all together
      
-
      It's time to put everything you've learned so far to good use.  I hope you were paying attention.
+
      It's time to put everything you've learned so far to good use. I hope you were paying attention.
 
      Example 8.20. The translate function, part 1
       def translate(url, dialectName="chef"): 1
     import urllib     2
@@ -6779,15 +6302,15 @@ def translate(url, dialectName="chef"): 1 
 
-The translate function has an optional argument dialectName, which is a string that specifies the dialect you'll be using.  You'll see how this is used in a minute.
+The translate function has an optional argument dialectName, which is a string that specifies the dialect you'll be using. You'll see how this is used in a minute.
 
 
 
 2 
 
-Hey, wait a minute, there's an import statement in this function!  That's perfectly legal in Python.  You're used to seeing import statements at the top of a program, which means that the imported module is available anywhere in the program.  But you can
-            also import modules within a function, which means that the imported module is only available within the function.  If you
-            have a module that is only ever used in one function, this is an easy way to make your code more modular.  (When you find
+Hey, wait a minute, there's an import statement in this function!  That's perfectly legal in Python. You're used to seeing import statements at the top of a program, which means that the imported module is available anywhere in the program. But you can
+            also import modules within a function, which means that the imported module is only available within the function. If you
+            have a module that is only ever used in one function, this is an easy way to make your code more modular. (When you find
             that your weekend hack has turned into an 800-line work of art and decide to split it up into a dozen reusable modules, you'll
             appreciate this.)
 
@@ -6809,30 +6332,30 @@ def translate(url, dialectName="chef"): 1 
 
 capitalize is a string method you haven't seen before; it simply capitalizes the first letter of a string and forces everything else
-            to lowercase.  Combined with some string formatting, you've taken the name of a dialect and transformed it into the name of the corresponding Dialectizer class.  If dialectName is the string 'chef', parserName will be the string 'ChefDialectizer'.
+            to lowercase. Combined with some string formatting, you've taken the name of a dialect and transformed it into the name of the corresponding Dialectizer class. If dialectName is the string 'chef', parserName will be the string 'ChefDialectizer'.
 
 
 
 2 
 
-You have the name of a class as a string (parserName), and you have the global namespace as a dictionary (globals()).  Combined, you can get a reference to the class which the string names.  (Remember, classes are objects, and they can be assigned to variables just like any other object.)  If parserName is the string 'ChefDialectizer', parserClass will be the class ChefDialectizer.
+You have the name of a class as a string (parserName), and you have the global namespace as a dictionary (globals()). Combined, you can get a reference to the class which the string names. (Remember, classes are objects, and they can be assigned to variables just like any other object.)  If parserName is the string 'ChefDialectizer', parserClass will be the class ChefDialectizer.
 
 
 
 3 
 
-Finally, you have a class object (parserClass), and you want an instance of the class.  Well, you already know how to do that: call the class like a function.  The fact that the class is being stored in a local variable makes absolutely no difference; you just call the local variable
-            like a function, and out pops an instance of the class.  If parserClass is the class ChefDialectizer, parser will be an instance of the class ChefDialectizer.
+Finally, you have a class object (parserClass), and you want an instance of the class. Well, you already know how to do that: call the class like a function. The fact that the class is being stored in a local variable makes absolutely no difference; you just call the local variable
+            like a function, and out pops an instance of the class. If parserClass is the class ChefDialectizer, parser will be an instance of the class ChefDialectizer.
 
 
 
-
      Why bother?  After all, there are only 3 Dialectizer classes; why not just use a case statement?  (Well, there's no case statement in Python, but why not just use a series of if statements?)  One reason: extensibility.  The translate function has absolutely no idea how many Dialectizer classes you've defined.  Imagine if you defined a new FooDialectizer tomorrow; translate would work by passing 'foo' as the dialectName.
-
      Even better, imagine putting FooDialectizer in a separate module, and importing it with from module import.  You've already seen that this includes it in globals(), so translate would still work without modification, even though FooDialectizer was in a separate file.
+
      Why bother?  After all, there are only 3 Dialectizer classes; why not just use a case statement?  (Well, there's no case statement in Python, but why not just use a series of if statements?)  One reason: extensibility. The translate function has absolutely no idea how many Dialectizer classes you've defined. Imagine if you defined a new FooDialectizer tomorrow; translate would work by passing 'foo' as the dialectName.
+
      Even better, imagine putting FooDialectizer in a separate module, and importing it with from module import. You've already seen that this includes it in globals(), so translate would still work without modification, even though FooDialectizer was in a separate file.
 
      Now imagine that the name of the dialect is coming from somewhere outside the program, maybe from a database or from a user-inputted
-value on a form.  You can use any number of server-side Python scripting architectures to dynamically generate web pages; this function could take a URL and a dialect name (both strings) in the query string of a web page request, and output the “translated” web page.
-
      Finally, imagine a Dialectizer framework with a plug-in architecture.  You could put each Dialectizer class in a separate file, leaving only the translate function in dialect.py.  Assuming a consistent naming scheme, the translate function could dynamic import the appropiate class from the appropriate file, given nothing but the dialect name.  (You haven't
+value on a form. You can use any number of server-side Python scripting architectures to dynamically generate web pages; this function could take a URL and a dialect name (both strings) in the query string of a web page request, and output the “translated” web page.
+
      Finally, imagine a Dialectizer framework with a plug-in architecture. You could put each Dialectizer class in a separate file, leaving only the translate function in dialect.py. Assuming a consistent naming scheme, the translate function could dynamic import the appropiate class from the appropriate file, given nothing but the dialect name. (You haven't
 seen dynamic importing yet, but I promise to cover it in a later chapter.)  To add a new dialect, you would simply add an
-appropriately-named file in the plug-ins directory (like foodialect.py which contains the FooDialectizer class).  Calling the translate function with the dialect name 'foo' would find the module foodialect.py, import the class FooDialectizer, and away you go.
+appropriately-named file in the plug-ins directory (like foodialect.py which contains the FooDialectizer class). Calling the translate function with the dialect name 'foo' would find the module foodialect.py, import the class FooDialectizer, and away you go.
 
      Example 8.22. The translate function, part 3
           parser.feed(htmlSource) 1
     parser.close()          2
@@ -6842,14 +6365,14 @@ appropriately-named file in the plug-ins directory (like foodialect.py
 1 
 
-After all that imagining, this is going to seem pretty boring, but the feed function is what does the entire transformation.  You had the entire HTML source in a single string, so you only had to call feed once.  However, you can call feed as often as you want, and the parser will just keep parsing.  So if you were worried about memory usage (or you knew you
-            were going to be dealing with very large HTML pages), you could set this up in a loop, where you read a few bytes of HTML and fed it to the parser.  The result would be the same.
+After all that imagining, this is going to seem pretty boring, but the feed function is what does the entire transformation. You had the entire HTML source in a single string, so you only had to call feed once. However, you can call feed as often as you want, and the parser will just keep parsing. So if you were worried about memory usage (or you knew you
+            were going to be dealing with very large HTML pages), you could set this up in a loop, where you read a few bytes of HTML and fed it to the parser. The result would be the same.
 
 
 
 2 
 
-Because feed maintains an internal buffer, you should always call the parser's close method when you're done (even if you fed it all at once, like you did).  Otherwise you may find that your output is missing
+Because feed maintains an internal buffer, you should always call the parser's close method when you're done (even if you fed it all at once, like you did). Otherwise you may find that your output is missing
             the last few bytes.
 
 
@@ -6864,11 +6387,11 @@ appropriately-named file in the plug-ins directory (like foodialect.py
 
      Further reading
      
 
        
-
      • You thought I was kidding about the server-side scripting idea.  So did I, until I found this web-based dialectizer.  Unfortunately, source code does not appear to be available.
+
      • You thought I was kidding about the server-side scripting idea. So did I, until I found this web-based dialectizer. Unfortunately, source code does not appear to be available.
 
 
      
 
      8.10. Summary
      
-
      Python provides you with a powerful tool, sgmllib.py, to manipulate HTML by turning its structure into an object model.  You can use this tool in many different ways.
+
      Python provides you with a powerful tool, sgmllib.py, to manipulate HTML by turning its structure into an object model. You can use this tool in many different ways.
 
      
 
        
 
      • parsing the HTML looking for something specific
@@ -6887,30 +6410,30 @@ appropriately-named file in the plug-ins directory (like foodialect.py
 

        
 
        
-
        [1] The technical term for a parser like SGMLParser is a consumer: it consumes HTML and breaks it down.  Presumably, the name feed was chosen to fit into the whole “consumer” motif.  Personally, it makes me think of an exhibit in the zoo where there's just a dark cage with no trees or plants or
+
        [1] The technical term for a parser like SGMLParser is a consumer: it consumes HTML and breaks it down. Presumably, the name feed was chosen to fit into the whole “consumer” motif. Personally, it makes me think of an exhibit in the zoo where there's just a dark cage with no trees or plants or
    evidence of life of any kind, but if you stand perfectly still and look really closely you can make out two beady eyes staring
    back at you from the far left corner, but you convince yourself that that's just your mind playing tricks on you, and the
-   only way you can tell that the whole thing isn't just an empty cage is a small innocuous sign on the railing that reads, “Do not feed the parser.”  But maybe that's just me.  In any event, it's an interesting mental image.
+   only way you can tell that the whole thing isn't just an empty cage is a small innocuous sign on the railing that reads, “Do not feed the parser.”  But maybe that's just me. In any event, it's an interesting mental image.
 
        
-
        [2] The reason Python is better at lists than strings is that lists are mutable but strings are immutable.  This means that appending to a list
-   just adds the element and updates the index.  Since strings can not be changed after they are created, code like s = s + newpiece will create an entirely new string out of the concatenation of the original and the new piece, then throw away the original
-   string.  This involves a lot of expensive memory management, and the amount of effort involved increases as the string gets
-   longer, so doing s = s + newpiece in a loop is deadly.  In technical terms, appending n items to a list is O(n), while appending n items to a string is O(n2).
+
        [2] The reason Python is better at lists than strings is that lists are mutable but strings are immutable. This means that appending to a list
+   just adds the element and updates the index. Since strings can not be changed after they are created, code like s = s + newpiece will create an entirely new string out of the concatenation of the original and the new piece, then throw away the original
+   string. This involves a lot of expensive memory management, and the amount of effort involved increases as the string gets
+   longer, so doing s = s + newpiece in a loop is deadly. In technical terms, appending n items to a list is O(n), while appending n items to a string is O(n2).
 
        
 
        [3] I don't get out much.
 
        
-
        [4] All right, it's not that common a question.  It's not up there with “What editor should I use to write Python code?” (answer: Emacs) or “Is Python better or worse than Perl?” (answer: “Perl is worse than Python because people wanted it worse.” -Larry Wall, 10/14/1998)  But questions about HTML processing pop up in one form or another about once a month, and among those questions, this is a popular one.
+
        [4] All right, it's not that common a question. It's not up there with “What editor should I use to write Python code?” (answer: Emacs) or “Is Python better or worse than Perl?” (answer: “Perl is worse than Python because people wanted it worse.” -Larry Wall, 10/14/1998)  But questions about HTML processing pop up in one form or another about once a month, and among those questions, this is a popular one.
 
        
 
        Chapter 9. XML Processing
        
 
        9.1. Diving in
        
-
        These next two chapters are about XML processing in Python.  It would be helpful if you already knew what an XML document looks like, that it's made up of structured tags to form a hierarchy of elements, and so on.  If this doesn't make
+
        These next two chapters are about XML processing in Python. It would be helpful if you already knew what an XML document looks like, that it's made up of structured tags to form a hierarchy of elements, and so on. If this doesn't make
 sense to you, there are many XML tutorials that can explain the basics.
 
        If you're not particularly interested in XML, you should still read these chapters, which cover important topics like Python packages, Unicode, command line arguments, and how to use getattr for method dispatching.
 
        Being a philosophy major is not required, although if you have ever had the misfortune of being subjected to the writings
 of Immanuel Kant, you will appreciate the example program a lot more than if you majored in something useful, like computer
 science.
-
        There are two basic ways to work with XML.  One is called SAX (“Simple API for XML”), and it works by reading the XML a little bit at a time and calling a method for each element it finds.  (If you read Chapter 8, HTML Processing, this should sound familiar, because that's how the sgmllib module works.)  The other is called DOM (“Document Object Model”), and it works by reading in the entire XML document at once and creating an internal representation of it using native Python classes linked in a tree structure.  Python has standard modules for both kinds of parsing, but this chapter will only deal with using the DOM.
-
        The following is a complete Python program which generates pseudo-random output based on a context-free grammar defined in an XML format.  Don't worry yet if you don't understand what that means; you'll examine both the program's input and its output
+
        There are two basic ways to work with XML. One is called SAX (“Simple API for XML”), and it works by reading the XML a little bit at a time and calling a method for each element it finds. (If you read Chapter 8, HTML Processing, this should sound familiar, because that's how the sgmllib module works.)  The other is called DOM (“Document Object Model”), and it works by reading in the entire XML document at once and creating an internal representation of it using native Python classes linked in a tree structure. Python has standard modules for both kinds of parsing, but this chapter will only deal with using the DOM.
+
        The following is a complete Python program which generates pseudo-random output based on a context-free grammar defined in an XML format. Don't worry yet if you don't understand what that means; you'll examine both the program's input and its output
 in more depth throughout these next two chapters.
 
        Example 9.1. kgp.py
        
 
        If you have not already done so, you can download this and other examples used in this book.
        @@ -6921,7 +6444,7 @@ Generates mock philosophy based on a context-free grammar
 Usage: python kgp.py [options] [source]
 
 Options:
-  -g ..., --grammar=...   use specified grammar file or URL
+  -g ..., --grammar=...  use specified grammar file or URL
   -h, --help              show this help
   -d    show debugging information while parsing
 
@@ -6977,7 +6500,7 @@ class KantGenerator:
         """guess default source of the current grammar
         
         The default source will be one of the <ref>s that is not
-        cross-referenced.  This sounds complicated but it's not.
+        cross-referenced. This sounds complicated but it's not.
         Example: The default source for kant.xml is
         "<xref id='section'/>", because 'section' is the one <ref>
         that is not <xref>'d anywhere in the grammar.
@@ -7031,9 +6554,9 @@ class KantGenerator:
         """parse a single XML node
         
         A parsed XML document (from minidom.parse) is a tree of nodes
-        of various types.  Each node is represented by an instance of the
+        of various types. Each node is represented by an instance of the
         corresponding Python class (Element for a tag, Text for
-        text data, Document for the top-level document).  The following
+        text data, Document for the top-level document). The following
         statement constructs the name of a class method based on the type
         of node we're parsing ("parse_Element" for an Element node,
         "parse_Text" for a Text node, etc.) and then calls the method.
@@ -7054,8 +6577,8 @@ class KantGenerator:
         """parse a text node
         
         The text of a text node is usually added to the output buffer
-        verbatim.  The one exception is that <p class='sentence'> sets
-        a flag to capitalize the first letter of the next word.  If
+        verbatim. The one exception is that <p class='sentence'> sets
+        a flag to capitalize the first letter of the next word. If
         that flag is set, we capitalize the text and reset the flag.
         """
         text = node.data
@@ -7071,7 +6594,7 @@ class KantGenerator:
         
         An XML element corresponds to an actual tag in the source:
         <xref id='...'>, <p chance='...'>, <choice>, etc.
-        Each element type is handled in its own method.  Like we did in
+        Each element type is handled in its own method. Like we did in
         parse(), we construct a method name based on the name of the
         element ("do_xref" for an <xref> tag, etc.) and
         call the method.
@@ -7090,7 +6613,7 @@ class KantGenerator:
         """handle <xref id='...'> tag
         
         An <xref id='...'> tag is a cross-reference to a <ref id='...'>
-        tag.  <xref id='sentence'/> evaluates to a randomly chosen child of
+        tag. <xref id='sentence'/> evaluates to a randomly chosen child of
         <ref id='sentence'>.
         """
         id = node.attributes["id"].value
@@ -7099,10 +6622,10 @@ class KantGenerator:
     def do_p(self, node):
         """handle <p> tag
         
-        The <p> tag is the core of the grammar.  It can contain almost
+        The <p> tag is the core of the grammar. It can contain almost
         anything: freeform text, <choice> tags, <xref> tags, even other
-        <p> tags.  If a "class='sentence'" attribute is found, a flag
-        is set and the next word will be capitalized.  If a "chance='X'"
+        <p> tags. If a "class='sentence'" attribute is found, a flag
+        is set and the next word will be capitalized. If a "chance='X'"
         attribute is found, there is an X% chance that the tag will be
         evaluated (and therefore a (100-X)% chance that it will be
         completely ignored)
@@ -7122,7 +6645,7 @@ class KantGenerator:
     def do_choice(self, node):
         """handle <choice> tag
         
-        A <choice> tag contains one or more <p> tags.  One <p> tag
+        A <choice> tag contains one or more <p> tags. One <p> tag
         is chosen at random and evaluated; the rest are ignored.
         """
         self.parse(self.randomChildElement(node))
@@ -7162,7 +6685,7 @@ def openAnything(source):
 
     This function lets you define parsers that take any input source
     (URL, pathname to local or network file, or actual data as a string)
-    and deal with it in a uniform manner.  Returned object is guaranteed
+    and deal with it in a uniform manner. Returned object is guaranteed
     to have all the basic stdio read methods (read, readline, readlines).
     Just .close() the object when you're done with it.
     
@@ -7207,49 +6730,49 @@ def openAnything(source):
 reference to ends, abstract from all content of knowledge; in the study
 of space, the discipline of human reason, in accordance with the
 principles of philosophy, is the clue to the discovery of the
-Transcendental Deduction.  The transcendental aesthetic, in all
+Transcendental Deduction. The transcendental aesthetic, in all
 theoretical sciences, occupies part of the sphere of human reason
 concerning the existence of our ideas in general; still, the
 never-ending regress in the series of empirical conditions constitutes
-the whole content for the transcendental unity of apperception.  What
+the whole content for the transcendental unity of apperception. What
 we have alone been able to show is that, even as this relates to the
 architectonic of human reason, the Ideal may not contradict itself, but
 it is still possible that it may be in contradictions with the
 employment of the pure employment of our hypothetical judgements, but
 natural causes (and I assert that this is the case) prove the validity
-of the discipline of pure reason.  As we have already seen, time (and
+of the discipline of pure reason. As we have already seen, time (and
 it is obvious that this is true) proves the validity of time, and the
 architectonic of human reason, in the full sense of these terms,
-abstracts from all content of knowledge.  I assert, in the case of the
+abstracts from all content of knowledge. I assert, in the case of the
 discipline of practical reason, that the Antinomies are just as
 necessary as natural causes, since knowledge of the phenomena is a
 posteriori.
     The discipline of human reason, as I have elsewhere shown, is by
 its very nature contradictory, but our ideas exclude the possibility of
-the Antinomies.  We can deduce that, on the contrary, the pure
+the Antinomies. We can deduce that, on the contrary, the pure
 employment of philosophy, on the contrary, is by its very nature
 contradictory, but our sense perceptions are a representation of, in
-the case of space, metaphysics.  The thing in itself is a
-representation of philosophy.  Applied logic is the clue to the
-discovery of natural causes.  However, what we have alone been able to
+the case of space, metaphysics. The thing in itself is a
+representation of philosophy. Applied logic is the clue to the
+discovery of natural causes. However, what we have alone been able to
 show is that our ideas, in other words, should only be used as a canon
 for the Ideal, because of our necessary ignorance of the conditions.
 
-[...snip...]
        This is, of course, complete gibberish.  Well, not complete gibberish.  It is syntactically and grammatically correct (although
-very verbose -- Kant wasn't what you would call a get-to-the-point kind of guy).  Some of it may actually be true (or at least
+[...snip...]
      This is, of course, complete gibberish. Well, not complete gibberish. It is syntactically and grammatically correct (although
+very verbose -- Kant wasn't what you would call a get-to-the-point kind of guy). Some of it may actually be true (or at least
 the sort of thing that Kant would have agreed with), some of it is blatantly false, and most of it is simply incoherent. 
 But all of it is in the style of Immanuel Kant.
 
      Let me repeat that this is much, much funnier if you are now or have ever been a philosophy major.
-
      The interesting thing about this program is that there is nothing Kant-specific about it.  All the content in the previous
-example was derived from the grammar file, kant.xml.  If you tell the program to use a different grammar file (which you can specify on the command line), the output will be
+
      The interesting thing about this program is that there is nothing Kant-specific about it. All the content in the previous
+example was derived from the grammar file, kant.xml. If you tell the program to use a different grammar file (which you can specify on the command line), the output will be
 completely different.
 
      Example 9.4. Simpler output from kgp.py
      [you@localhost kgp]$ python kgp.py -g binary.xml
 00101001
 [you@localhost kgp]$ python kgp.py -g binary.xml
-10110100
      You will take a closer look at the structure of the grammar file later in this chapter.  For now, all you need to know is
+10110100
      You will take a closer look at the structure of the grammar file later in this chapter. For now, all you need to know is
 that the grammar file defines the structure of the output, and the kgp.py program reads through the grammar and makes random decisions about which words to plug in where.
 
      9.2. Packages
      
-
      Actually parsing an XML document is very simple: one line of code.  However, before you get to that line of code, you need to take a short detour
+
      Actually parsing an XML document is very simple: one line of code. However, before you get to that line of code, you need to take a short detour
    to talk about packages.
 
      Example 9.5. Loading an XML document (a sneak peek)
       >>> from xml.dom import minidom 1
@@ -7258,12 +6781,12 @@ that the grammar file defines the structure of the output, and the kgp.py<
 
 1 
 
-This is a syntax you haven't seen before.  It looks almost like the from module import you know and love, but the "." gives it away as something above and beyond a simple import.  In fact, xml is what is known as a package, dom is a nested package within xml, and minidom is a module within xml.dom.
+This is a syntax you haven't seen before. It looks almost like the from module import you know and love, but the "." gives it away as something above and beyond a simple import. In fact, xml is what is known as a package, dom is a nested package within xml, and minidom is a module within xml.dom.
 
 
 
-
      That sounds complicated, but it's really not.  Looking at the actual implementation may help.  Packages are little more than
-directories of modules; nested packages are subdirectories.  The modules within a package (or a nested package) are still
+
      That sounds complicated, but it's really not. Looking at the actual implementation may help. Packages are little more than
+directories of modules; nested packages are subdirectories. The modules within a package (or a nested package) are still
 just .py files, like always, except that they're in a subdirectory instead of the main lib/ directory of your Python installation.
 
      Example 9.6. File layout of a package
      Python21/           root Python installation (home of the executable)
 |
@@ -7275,8 +6798,8 @@ just .py files, like always, except that they're in a subdirectory
        |
        +--dom/      xml.dom package (contains minidom.py)
        |
-       +--parsers/  xml.parsers package (used internally)
      So when you say from xml.dom import minidom, Python figures out that that means “look in the xml directory for a dom directory, and look in that for the minidom module, and import it as minidom”.  But Python is even smarter than that; not only can you import entire modules contained within a package, you can selectively import
-specific classes or functions from a module contained within a package.  You can also import the package itself as a module.
+       +--parsers/  xml.parsers package (used internally)
      So when you say from xml.dom import minidom, Python figures out that that means “look in the xml directory for a dom directory, and look in that for the minidom module, and import it as minidom”. But Python is even smarter than that; not only can you import entire modules contained within a package, you can selectively import
+specific classes or functions from a module contained within a package. You can also import the package itself as a module.
 The syntax is all the same; Python figures out what you mean based on the file layout of the package, and automatically does the right thing.
 
      Example 9.7. Packages are modules, too
      >>> from xml.dom import minidom         1
 >>> minidom
@@ -7298,19 +6821,19 @@ The syntax is all the same; Python figures out what you mean based on the file l
 
 1 
 
-Here you're importing a module (minidom) from a nested package (xml.dom).  The result is that minidom is imported into your namespace, and in order to reference classes within the minidom module (like Element), you need to preface them with the module name.
+Here you're importing a module (minidom) from a nested package (xml.dom). The result is that minidom is imported into your namespace, and in order to reference classes within the minidom module (like Element), you need to preface them with the module name.
 
 
 
 2 
 
-Here you are importing a class (Element) from a module (minidom) from a nested package (xml.dom).  The result is that Element is imported directly into your namespace.  Note that this does not interfere with the previous import; the Element class can now be referenced in two ways (but it's all still the same class).
+Here you are importing a class (Element) from a module (minidom) from a nested package (xml.dom). The result is that Element is imported directly into your namespace. Note that this does not interfere with the previous import; the Element class can now be referenced in two ways (but it's all still the same class).
 
 
 
 3 
 
-Here you are importing the dom package (a nested package of xml) as a module in and of itself.  Any level of a package can be treated as a module, as you'll see in a moment.  It can even
+Here you are importing the dom package (a nested package of xml) as a module in and of itself. Any level of a package can be treated as a module, as you'll see in a moment. It can even
             have its own attributes and methods, just the modules you've seen before.
 
 
@@ -7322,22 +6845,22 @@ The syntax is all the same; Python figures out what you mean based on the file l
 
 
 
      So how can a package (which is just a directory on disk) be imported and treated as a module (which is always a file on disk)?
-The answer is the magical __init__.py file.  You see, packages are not simply directories; they are directories with a specific file, __init__.py, inside.  This file defines the attributes and methods of the package.  For instance, xml.dom contains a Node class, which is defined in xml/dom/__init__.py.  When you import a package as a module (like dom from xml), you're really importing its __init__.py file.
+The answer is the magical __init__.py file. You see, packages are not simply directories; they are directories with a specific file, __init__.py, inside. This file defines the attributes and methods of the package. For instance, xml.dom contains a Node class, which is defined in xml/dom/__init__.py. When you import a package as a module (like dom from xml), you're really importing its __init__.py file.
      
-
      
 
      
 Note
 
      
 
      A package is a directory with the special __init__.py file in it.  The __init__.py file defines the attributes and methods of the package.  It doesn't need to define anything; it can just be an empty file,
-      but it has to exist.  But if __init__.py doesn't exist, the directory is just a directory, not a package, and it can't be imported or contain modules or nested packages.
+A package is a directory with the special __init__.py file in it. The __init__.py file defines the attributes and methods of the package. It doesn't need to define anything; it can just be an empty file,
+      but it has to exist. But if __init__.py doesn't exist, the directory is just a directory, not a package, and it can't be imported or contain modules or nested packages.
 
 
      
 
      
-
      So why bother with packages?  Well, they provide a way to logically group related modules.  Instead of having an xml package with sax and dom packages inside, the authors could have chosen to put all the sax functionality in xmlsax.py and all the dom functionality in xmldom.py, or even put all of it in a single module.  But that would have been unwieldy (as of this writing, the XML package has over 3000 lines of code) and difficult to manage (separate source files mean multiple people can work on different
+
      So why bother with packages?  Well, they provide a way to logically group related modules. Instead of having an xml package with sax and dom packages inside, the authors could have chosen to put all the sax functionality in xmlsax.py and all the dom functionality in xmldom.py, or even put all of it in a single module. But that would have been unwieldy (as of this writing, the XML package has over 3000 lines of code) and difficult to manage (separate source files mean multiple people can work on different
 areas simultaneously).
 
      If you ever find yourself writing a large subsystem in Python (or, more likely, when you realize that your small subsystem has grown into a large one), invest some time designing a good
-package architecture.  It's one of the many things Python is good at, so take advantage of it.
+package architecture. It's one of the many things Python is good at, so take advantage of it.
 
      9.3. Parsing XML
      
-
      As I was saying, actually parsing an XML document is very simple: one line of code.  Where you go from there is up to you.
+
      As I was saying, actually parsing an XML document is very simple: one line of code. Where you go from there is up to you.
 
      Example 9.8. Loading an XML document (for real this time)
       >>> from xml.dom import minidom      1
 >>> xmldoc = minidom.parse('~/diveintopython3/common/py/kgp/binary.xml')  2
@@ -7365,20 +6888,20 @@ package architecture.  It's one of the many things Python is good at, so take ad
 
 2 
 
-Here is the one line of code that does all the work: minidom.parse takes one argument and returns a parsed representation of the XML document.  The argument can be many things; in this case, it's simply a filename of an XML document on my local disk.  (To follow along, you'll need to change the path to point to your downloaded examples directory.)
-             But you can also pass a file object, or even a file-like object.  You'll take advantage of this flexibility later in this chapter.
+Here is the one line of code that does all the work: minidom.parse takes one argument and returns a parsed representation of the XML document. The argument can be many things; in this case, it's simply a filename of an XML document on my local disk. (To follow along, you'll need to change the path to point to your downloaded examples directory.)
+             But you can also pass a file object, or even a file-like object. You'll take advantage of this flexibility later in this chapter.
 
 
 
 3 
 
-The object returned from minidom.parse is a Document object, a descendant of the Node class.  This Document object is the root level of a complex tree-like structure of interlocking Python objects that completely represent the XML document you passed to minidom.parse.
+The object returned from minidom.parse is a Document object, a descendant of the Node class. This Document object is the root level of a complex tree-like structure of interlocking Python objects that completely represent the XML document you passed to minidom.parse.
 
 
 
 4 
 
-toxml is a method of the Node class (and is therefore available on the Document object you got from minidom.parse).  toxml prints out the XML that this Node represents.  For the Document node, this prints out the entire XML document.
+toxml is a method of the Node class (and is therefore available on the Document object you got from minidom.parse). toxml prints out the XML that this Node represents. For the Document node, this prints out the entire XML document.
 
 
 
@@ -7394,20 +6917,20 @@ package architecture.  It's one of the many things Python is good at, so take ad
 
 1 
 
-Every Node has a childNodes attribute, which is a list of the Node objects.  A Document always has only one child node, the root element of the XML document (in this case, the grammar element).
+Every Node has a childNodes attribute, which is a list of the Node objects. A Document always has only one child node, the root element of the XML document (in this case, the grammar element).
 
 
 
 2 
 
-To get the first (and in this case, the only) child node, just use regular list syntax.  Remember, there is nothing special
+To get the first (and in this case, the only) child node, just use regular list syntax. Remember, there is nothing special
             going on here; this is just a regular Python list of regular Python objects.
 
 
 
 3 
 
-Since getting the first child node of a node is a useful and common activity, the Node class has a firstChild attribute, which is synonymous with childNodes[0].  (There is also a lastChild attribute, which is synonymous with childNodes[-1].)
+Since getting the first child node of a node is a useful and common activity, the Node class has a firstChild attribute, which is synonymous with childNodes[0]. (There is also a lastChild attribute, which is synonymous with childNodes[-1].)
 
 
 
@@ -7458,7 +6981,7 @@ package architecture.  It's one of the many things Python is good at, so take ad
 
 1 
 
-Looking at the XML in binary.xml, you might think that the grammar has only two child nodes, the two ref elements.  But you're missing something: the carriage returns!  After the '<grammar>' and before the first '<ref>' is a carriage return, and this text counts as a child node of the grammar element.  Similarly, there is a carriage return after each '</ref>'; these also count as child nodes.  So grammar.childNodes is actually a list of 5 objects: 3 Text objects and 2 Element objects.
+Looking at the XML in binary.xml, you might think that the grammar has only two child nodes, the two ref elements. But you're missing something: the carriage returns!  After the '<grammar>' and before the first '<ref>' is a carriage return, and this text counts as a child node of the grammar element. Similarly, there is a carriage return after each '</ref>'; these also count as child nodes. So grammar.childNodes is actually a list of 5 objects: 3 Text objects and 2 Element objects.
 
 
 
@@ -7533,34 +7056,34 @@ u'0'
      
 
 5 
 
-The .data attribute of a Text node gives you the actual string that the text node represents.  But what is that 'u' in front of the string?  The answer to that deserves its own section.
+The .data attribute of a Text node gives you the actual string that the text node represents. But what is that 'u' in front of the string?  The answer to that deserves its own section.
 
 
 
 
      9.4. Unicode
      
-
      Unicode is a system to represent characters from all the world's different languages.  When Python parses an XML document, all data is stored in memory as unicode.
+
      Unicode is a system to represent characters from all the world's different languages. When Python parses an XML document, all data is stored in memory as unicode.
 
      You'll get to all that in a minute, but first, some background.
 
      Historical note. Before unicode, there were separate character encoding systems for each language, each using the same numbers (0-255) to represent
-that language's characters.  Some languages (like Russian) have multiple conflicting standards about how to represent the
+that language's characters. Some languages (like Russian) have multiple conflicting standards about how to represent the
 same characters; other languages (like Japanese) have so many characters that they require multiple-byte character sets. 
 Exchanging documents between systems was difficult because there was no way for a computer to tell for certain which character
 encoding scheme the document author had used; the computer only saw numbers, and the numbers could mean different things.
 Then think about trying to store these documents in the same place (like in the same database table); you would need to store
 the character encoding alongside each piece of text, and make sure to pass it around whenever you passed the text around.
-Then think about multilingual documents, with characters from multiple languages in the same document.  (They typically used
+Then think about multilingual documents, with characters from multiple languages in the same document. (They typically used
 escape codes to switch modes; poof, you're in Russian koi8-r mode, so character 241 means this; poof, now you're in Mac Greek
-mode, so character 241 means something else.  And so on.)  These are the problems which unicode was designed to solve.
-
      To solve these problems, unicode represents each character as a 2-byte number, from 0 to 65535.[5]  Each 2-byte number represents a unique character used in at least one of the world's languages.  (Characters that are used
+mode, so character 241 means something else. And so on.)  These are the problems which unicode was designed to solve.
+
      To solve these problems, unicode represents each character as a 2-byte number, from 0 to 65535.[5]  Each 2-byte number represents a unique character used in at least one of the world's languages. (Characters that are used
 in multiple languages have the same numeric code.)  There is exactly 1 number per character, and exactly 1 character per number.
 Unicode data is never ambiguous.
-
      Of course, there is still the matter of all these legacy encoding systems.  7-bit ASCII, for instance, which stores English characters as numbers ranging from 0 to 127.  (65 is capital “A”, 97 is lowercase “a”, and so forth.)  English has a very simple alphabet, so it can be completely expressed in 7-bit ASCII.  Western European languages like French, Spanish, and German all use an encoding system called ISO-8859-1 (also called “latin-1”), which uses the 7-bit ASCII characters for the numbers 0 through 127, but then extends into the 128-255 range for characters like n-with-a-tilde-over-it
-(241), and u-with-two-dots-over-it (252).  And unicode uses the same characters as 7-bit ASCII for 0 through 127, and the same characters as ISO-8859-1 for 128 through 255, and then extends from there into characters
+
      Of course, there is still the matter of all these legacy encoding systems. 7-bit ASCII, for instance, which stores English characters as numbers ranging from 0 to 127. (65 is capital “A”, 97 is lowercase “a”, and so forth.)  English has a very simple alphabet, so it can be completely expressed in 7-bit ASCII. Western European languages like French, Spanish, and German all use an encoding system called ISO-8859-1 (also called “latin-1”), which uses the 7-bit ASCII characters for the numbers 0 through 127, but then extends into the 128-255 range for characters like n-with-a-tilde-over-it
+(241), and u-with-two-dots-over-it (252). And unicode uses the same characters as 7-bit ASCII for 0 through 127, and the same characters as ISO-8859-1 for 128 through 255, and then extends from there into characters
 for other languages with the remaining numbers, 256 through 65535.
 
      When dealing with unicode data, you may at some point need to convert the data back into one of these other legacy encoding
-systems.  For instance, to integrate with some other computer system which expects its data in a specific 1-byte encoding
-scheme, or to print it to a non-unicode-aware terminal or printer.  Or to store it in an XML document which explicitly specifies the encoding scheme.
+systems. For instance, to integrate with some other computer system which expects its data in a specific 1-byte encoding
+scheme, or to print it to a non-unicode-aware terminal or printer. Or to store it in an XML document which explicitly specifies the encoding scheme.
 
      And on that note, let's get back to Python.
-
      Python has had unicode support throughout the language since version 2.0.  The XML package uses unicode to store all parsed XML data, but you can use unicode anywhere.
+
      Python has had unicode support throughout the language since version 2.0. The XML package uses unicode to store all parsed XML data, but you can use unicode anywhere.
 
      Example 9.13. Introducing unicode
       >>> s = u'Dive in'            1
 >>> s
@@ -7571,13 +7094,13 @@ Dive in
      
 
 1 
 
-To create a unicode string instead of a regular ASCII string, add the letter “u” before the string.  Note that this particular string doesn't have any non-ASCII characters.  That's fine; unicode is a superset of ASCII (a very large superset at that), so any regular ASCII string can also be stored as unicode.
+To create a unicode string instead of a regular ASCII string, add the letter “u” before the string. Note that this particular string doesn't have any non-ASCII characters. That's fine; unicode is a superset of ASCII (a very large superset at that), so any regular ASCII string can also be stored as unicode.
 
 
 
 2 
 
-When printing a string, Python will attempt to convert it to your default encoding, which is usually ASCII.  (More on this in a minute.)  Since this unicode string is made up of characters that are also ASCII characters, printing it has the same result as printing a normal ASCII string; the conversion is seamless, and if you didn't know that s was a unicode string, you'd never notice the difference.
+When printing a string, Python will attempt to convert it to your default encoding, which is usually ASCII. (More on this in a minute.)  Since this unicode string is made up of characters that are also ASCII characters, printing it has the same result as printing a normal ASCII string; the conversion is seamless, and if you didn't know that s was a unicode string, you'd never notice the difference.
 
 
 
@@ -7593,7 +7116,7 @@ La Peña
      
 
 1 
 
-The real advantage of unicode, of course, is its ability to store non-ASCII characters, like the Spanish “ñ” (n with a tilde over it).  The unicode character code for the tilde-n is 0xf1 in hexadecimal (241 in decimal), which you can type like this: \xf1.
+The real advantage of unicode, of course, is its ability to store non-ASCII characters, like the Spanish “ñ” (n with a tilde over it). The unicode character code for the tilde-n is 0xf1 in hexadecimal (241 in decimal), which you can type like this: \xf1.
 
 
 
@@ -7605,8 +7128,8 @@ La Peña
      
 
 3 
 
-Here's where the conversion-from-unicode-to-other-encoding-schemes comes in.  s is a unicode string, but print can only print a regular string.  To solve this problem, you call the encode method, available on every unicode string, to convert the unicode string to a regular string in the given encoding scheme,
-            which you pass as a parameter.  In this case, you're using latin-1 (also known as iso-8859-1), which includes the tilde-n (whereas the default ASCII encoding scheme did not, since it only includes characters numbered 0 through 127).
+Here's where the conversion-from-unicode-to-other-encoding-schemes comes in. s is a unicode string, but print can only print a regular string. To solve this problem, you call the encode method, available on every unicode string, to convert the unicode string to a regular string in the given encoding scheme,
+            which you pass as a parameter. In this case, you're using latin-1 (also known as iso-8859-1), which includes the tilde-n (whereas the default ASCII encoding scheme did not, since it only includes characters numbered 0 through 127).
 
 
 
@@ -7623,14 +7146,14 @@ sys.setdefaultencoding('iso-8859-1') 1 
 
-sitecustomize.py is a special script; Python will try to import it on startup, so any code in it will be run automatically.  As the comment mentions, it can go anywhere
+sitecustomize.py is a special script; Python will try to import it on startup, so any code in it will be run automatically. As the comment mentions, it can go anywhere
             (as long as import can find it), but it usually goes in the site-packages directory within your Python lib directory.
 
 
 
 2 
 
-setdefaultencoding function sets, well, the default encoding.  This is the encoding scheme that Python will try to use whenever it needs to auto-coerce a unicode string into a regular string.
+setdefaultencoding function sets, well, the default encoding. This is the encoding scheme that Python will try to use whenever it needs to auto-coerce a unicode string into a regular string.
 
 
 
@@ -7645,8 +7168,8 @@ La Peña
      
 
 1 
 
-This example assumes that you have made the changes listed in the previous example to your sitecustomize.py file, and restarted Python.  If your default encoding still says 'ascii', you didn't set up your sitecustomize.py properly, or you didn't restart Python.  The default encoding can only be changed during Python startup; you can't change it later.  (Due to some wacky programming tricks that I won't get into right now, you can't even
-            call sys.setdefaultencoding after Python has started up.  Dig into site.py and search for “setdefaultencoding” to find out how.)
+This example assumes that you have made the changes listed in the previous example to your sitecustomize.py file, and restarted Python. If your default encoding still says 'ascii', you didn't set up your sitecustomize.py properly, or you didn't restart Python. The default encoding can only be changed during Python startup; you can't change it later. (Due to some wacky programming tricks that I won't get into right now, you can't even
+            call sys.setdefaultencoding after Python has started up. Dig into site.py and search for “setdefaultencoding” to find out how.)
 
 
 
@@ -7657,11 +7180,11 @@ La Peña
      
 
 
 
      Example 9.17. Specifying encoding in .py files
      
-
      If you are going to be storing non-ASCII strings within your Python code, you'll need to specify the encoding of each individual .py file by putting an encoding declaration at the top of each file.  This declaration defines the .py file to be UTF-8:
      +
      If you are going to be storing non-ASCII strings within your Python code, you'll need to specify the encoding of each individual .py file by putting an encoding declaration at the top of each file. This declaration defines the .py file to be UTF-8:
       #!/usr/bin/env python
 # -*- coding: UTF-8 -*-
-
      Now, what about XML?  Well, every XML document is in a specific encoding.  Again, ISO-8859-1 is a popular encoding for data in Western European languages.  KOI8-R
-is popular for Russian texts.  The encoding, if specified, is in the header of the XML document.
+
      Now, what about XML?  Well, every XML document is in a specific encoding. Again, ISO-8859-1 is a popular encoding for data in Western European languages. KOI8-R
+is popular for Russian texts. The encoding, if specified, is in the header of the XML document.
 
      Example 9.18. russiansample.xml
      
 <?xml version="1.0" encoding="koi8-r"?>       1
 <preface>
@@ -7671,13 +7194,13 @@ is popular for Russian texts.  The encoding, if specified, is in the header of t
 
 1 
 
-This is a sample extract from a real Russian XML document; it's part of a Russian translation of this very book.  Note the encoding, koi8-r, specified in the header.
+This is a sample extract from a real Russian XML document; it's part of a Russian translation of this very book. Note the encoding, koi8-r, specified in the header.
 
 
 
 2 
 
-These are Cyrillic characters which, as far as I know, spell the Russian word for “Preface”.  If you open this file in a regular text editor, the characters will most likely like gibberish, because they're encoded
+These are Cyrillic characters which, as far as I know, spell the Russian word for “Preface”. If you open this file in a regular text editor, the characters will most likely like gibberish, because they're encoded
             using the koi8-r encoding scheme, but they're being displayed in iso-8859-1.
 
 
@@ -7701,7 +7224,7 @@ UnicodeError: ASCII encoding error: ordinal not in range(128)
 
 1 
 
-I'm assuming here that you saved the previous example as russiansample.xml in the current directory.  I am also, for the sake of completeness, assuming that you've changed your default encoding back
+I'm assuming here that you saved the previous example as russiansample.xml in the current directory. I am also, for the sake of completeness, assuming that you've changed your default encoding back
             to 'ascii' by removing your sitecustomize.py file, or at least commenting out the setdefaultencoding line.
 
 
@@ -7727,13 +7250,13 @@ UnicodeError: ASCII encoding error: ordinal not in range(128)
 
 5 
 
-Printing the koi8-r-encoded string will probably show gibberish on your screen, because your Python IDE is interpreting those characters as iso-8859-1, not koi8-r.  But at least they do print.  (And, if you look carefully, it's the same gibberish that you saw when you opened the original
-XML document in a non-unicode-aware text editor.  Python converted it from koi8-r into unicode when it parsed the XML document, and you've just converted it back.)
+Printing the koi8-r-encoded string will probably show gibberish on your screen, because your Python IDE is interpreting those characters as iso-8859-1, not koi8-r. But at least they do print. (And, if you look carefully, it's the same gibberish that you saw when you opened the original
+XML document in a non-unicode-aware text editor. Python converted it from koi8-r into unicode when it parsed the XML document, and you've just converted it back.)
 
 
 
 
      To sum up, unicode itself is a bit intimidating if you've never seen it before, but unicode data is really very easy to handle
-in Python.  If your XML documents are all 7-bit ASCII (like the examples in this chapter), you will literally never think about unicode.  Python will convert the ASCII data in the XML documents into unicode while parsing, and auto-coerce it back to ASCII whenever necessary, and you'll never even notice.  But if you need to deal with that in other languages, Python is ready.
+in Python. If your XML documents are all 7-bit ASCII (like the examples in this chapter), you will literally never think about unicode. Python will convert the ASCII data in the XML documents into unicode while parsing, and auto-coerce it back to ASCII whenever necessary, and you'll never even notice. But if you need to deal with that in other languages, Python is ready.
 
      
 
      Further reading
      
 
        
@@ -7745,7 +7268,7 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 
      
 
      9.5. Searching for elements
      
-
      Traversing XML documents by stepping through each node can be tedious.  If you're looking for something in particular, buried deep within
+
      Traversing XML documents by stepping through each node can be tedious. If you're looking for something in particular, buried deep within
    your XML document, there is a shortcut you can use to find it quickly: getElementsByTagName.
 
      For this section, you'll be using the binary.xml grammar file, which looks like this:
 
      Example 9.20. binary.xml
      <?xml version="1.0"?>
@@ -7759,7 +7282,7 @@ in Python.  If your XML documents are all 7-bit ASCI
   <p><xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/>\
 <xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/></p>
 </ref>
-</grammar>
      It has two refs, 'bit' and 'byte'.  A bit is either a '0' or '1', and a byte is 8 bits.
+</grammar>
      It has two refs, 'bit' and 'byte'. A bit is either a '0' or '1', and a byte is 8 bits.
 
      Example 9.21. Introducing getElementsByTagName
       >>> from xml.dom import minidom
 >>> xmldoc = minidom.parse('binary.xml')
@@ -7781,7 +7304,7 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 1 
 
-getElementsByTagName takes one argument, the name of the element you wish to find.  It returns a list of Element objects, corresponding to the XML elements that have that name.  In this case, you find two ref elements.
+getElementsByTagName takes one argument, the name of the element you wish to find. It returns a list of Element objects, corresponding to the XML elements that have that name. In this case, you find two ref elements.
 
 
 
@@ -7815,7 +7338,7 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 3 
 
-Just as before, the getElementsByTagName method returns a list of all the elements it found.  In this case, you have two, one for each bit.
+Just as before, the getElementsByTagName method returns a list of all the elements it found. In this case, you have two, one for each bit.
 
 
 
@@ -7834,7 +7357,7 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 1 
 
-Note carefully the difference between this and the previous example.  Previously, you were searching for p elements within firstref, but here you are searching for p elements within xmldoc, the root-level object that represents the entire XML document.  This does find the p elements nested within the ref elements within the root grammar element.
+Note carefully the difference between this and the previous example. Previously, you were searching for p elements within firstref, but here you are searching for p elements within xmldoc, the root-level object that represents the entire XML document. This does find the p elements nested within the ref elements within the root grammar element.
 
 
 
@@ -7857,7 +7380,7 @@ in Python.  If your XML documents are all 7-bit ASCI
 Note
 
 
-This section may be a little confusing, because of some overlapping terminology.  Elements in an XML document have attributes, and Python objects also have attributes.  When you parse an XML document, you get a bunch of Python objects that represent all the pieces of the XML document, and some of these Python objects represent attributes of the XML elements.  But the (Python) objects that represent the (XML) attributes also have (Python) attributes, which are used to access various parts of the (XML) attribute that the object represents.  I told you it was confusing.  I am open to suggestions on how to distinguish these
+This section may be a little confusing, because of some overlapping terminology. Elements in an XML document have attributes, and Python objects also have attributes. When you parse an XML document, you get a bunch of Python objects that represent all the pieces of the XML document, and some of these Python objects represent attributes of the XML elements. But the (Python) objects that represent the (XML) attributes also have (Python) attributes, which are used to access various parts of the (XML) attribute that the object represents. I told you it was confusing. I am open to suggestions on how to distinguish these
       more clearly.
 
 
@@ -7883,13 +7406,13 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 1 
 
-Each Element object has an attribute called attributes, which is a NamedNodeMap object.  This sounds scary, but it's not, because a NamedNodeMap is an object that acts like a dictionary, so you already know how to use it.
+Each Element object has an attribute called attributes, which is a NamedNodeMap object. This sounds scary, but it's not, because a NamedNodeMap is an object that acts like a dictionary, so you already know how to use it.
 
 
 
 2 
 
-Treating the NamedNodeMap as a dictionary, you can get a list of the names of the attributes of this element by using attributes.keys().  This element has only one attribute, 'id'.
+Treating the NamedNodeMap as a dictionary, you can get a list of the names of the attributes of this element by using attributes.keys(). This element has only one attribute, 'id'.
 
 
 
@@ -7901,14 +7424,14 @@ in Python.  If your XML documents are all 7-bit ASCI
 
 4 
 
-Again treating the NamedNodeMap as a dictionary, you can get a list of the values of the attributes by using attributes.values().  The values are themselves objects, of type Attr.  You'll see how to get useful information out of this object in the next example.
+Again treating the NamedNodeMap as a dictionary, you can get a list of the values of the attributes by using attributes.values(). The values are themselves objects, of type Attr. You'll see how to get useful information out of this object in the next example.
 
 
 
 5 
 
-Still treating the NamedNodeMap as a dictionary, you can access an individual attribute by name, using normal dictionary syntax.  (Readers who have been
-            paying extra-close attention will already know how the NamedNodeMap class accomplishes this neat trick: by defining a __getitem__ special method.  Other readers can take comfort in the fact that they don't need to understand how it works in order to use it effectively.)
+Still treating the NamedNodeMap as a dictionary, you can access an individual attribute by name, using normal dictionary syntax. (Readers who have been
+            paying extra-close attention will already know how the NamedNodeMap class accomplishes this neat trick: by defining a __getitem__ special method. Other readers can take comfort in the fact that they don't need to understand how it works in order to use it effectively.)
 
 
 
@@ -7924,7 +7447,7 @@ u'bit'
      
 
 1 
 
-The Attr object completely represents a single XML attribute of a single XML element.  The name of the attribute (the same name as you used to find this object in the bitref.attributes NamedNodeMap pseudo-dictionary) is stored in a.name.
+The Attr object completely represents a single XML attribute of a single XML element. The name of the attribute (the same name as you used to find this object in the bitref.attributes NamedNodeMap pseudo-dictionary) is stored in a.name.
 
 
 
@@ -7939,13 +7462,13 @@ u'bit'
      
 Note
 
 
-Like a dictionary, attributes of an XML element have no ordering.  Attributes may happen to be listed in a certain order in the original XML document, and the Attr objects may happen to be listed in a certain order when the XML document is parsed into Python objects, but these orders are arbitrary and should carry no special meaning.  You should always access individual attributes
+Like a dictionary, attributes of an XML element have no ordering. Attributes may happen to be listed in a certain order in the original XML document, and the Attr objects may happen to be listed in a certain order when the XML document is parsed into Python objects, but these orders are arbitrary and should carry no special meaning. You should always access individual attributes
       by name, like the keys of a dictionary.
 
 
 
 
      9.7. Segue
      
-
      OK, that's it for the hard-core XML stuff.  The next chapter will continue to use these same example programs, but focus on
+
      OK, that's it for the hard-core XML stuff. The next chapter will continue to use these same example programs, but focus on
    other aspects that make the program more flexible: using streams for input processing, using getattr for method dispatching, and using command-line flags to allow users to reconfigure the program without changing the code.
 
      Before moving on to the next chapter, you should be comfortable doing all of these things:
 
      
@@ -7957,20 +7480,20 @@ u'bit'
    
 
 

    
 
    
-
    [5] This, sadly, is still an oversimplification.  Unicode now has been extended to handle ancient Chinese, Korean, and Japanese texts, which had so
-   many different characters that the 2-byte unicode system could not represent them all.  But Python doesn't currently support that out of the box, and I don't know if there is a project afoot to add it.  You've reached the
+
    [5] This, sadly, is still an oversimplification. Unicode now has been extended to handle ancient Chinese, Korean, and Japanese texts, which had so
+   many different characters that the 2-byte unicode system could not represent them all. But Python doesn't currently support that out of the box, and I don't know if there is a project afoot to add it. You've reached the
    limits of my expertise, sorry.
 
    
 
    Chapter 10. Scripts and Streams
    
 
    10.1. Abstracting input sources
    
 
    One of Python's greatest strengths is its dynamic binding, and one powerful use of dynamic binding is the file-like object.
 
    Many functions which require an input source could simply take a filename, go open the file for reading, read it, and close
-it when they're done.  But they don't.  Instead, they take a file-like object.
-
    In the simplest case, a file-like object is any object with a read method with an optional size parameter, which returns a string.  When called with no size parameter, it reads everything there is to read from the input source and returns all the data as a single string.  When
+it when they're done. But they don't. Instead, they take a file-like object.
+
    In the simplest case, a file-like object is any object with a read method with an optional size parameter, which returns a string. When called with no size parameter, it reads everything there is to read from the input source and returns all the data as a single string. When
 called with a size parameter, it reads that much from the input source and returns that much data; when called again, it picks up where it left
 off and returns the next chunk of data.
-
    This is how reading from real files works; the difference is that you're not limiting yourself to real files.  The input source could be anything: a file on
-disk, a web page, even a hard-coded string.  As long as you pass a file-like object to the function, and the function simply
+
    This is how reading from real files works; the difference is that you're not limiting yourself to real files. The input source could be anything: a file on
+disk, a web page, even a hard-coded string. As long as you pass a file-like object to the function, and the function simply
 calls the object's read method, the function can handle any kind of input source without specific code to handle each kind.
 
    In case you were wondering how this relates to XML processing, minidom.parse is one such function which can take a file-like object.
 
    Example 10.1. Parsing XML from a file
    @@ -7994,7 +7517,7 @@ calls the object's read method, the function can handle any kind of
 
 1 
 
-First, you open the file on disk.  This gives you a file object.
+First, you open the file on disk. This gives you a file object.
 
 
 
@@ -8006,7 +7529,7 @@ calls the object's read method, the function can handle any kind of
 
 3 
 
-Be sure to call the close method of the file object after you're done with it.  minidom.parse will not do this for you.
+Be sure to call the close method of the file object after you're done with it. minidom.parse will not do this for you.
 
 
 
@@ -8016,8 +7539,8 @@ calls the object's read method, the function can handle any kind of
 
 
 
-
    Well, that all seems like a colossal waste of time.  After all, you've already seen that minidom.parse can simply take the filename and do all the opening and closing nonsense automatically.  And it's true that if you know you're
-just going to be parsing a local file, you can pass the filename and minidom.parse is smart enough to Do The Right Thing™.  But notice how similar -- and easy -- it is to parse an XML document straight from the Internet.
+
    Well, that all seems like a colossal waste of time. After all, you've already seen that minidom.parse can simply take the filename and do all the opening and closing nonsense automatically. And it's true that if you know you're
+just going to be parsing a local file, you can pass the filename and minidom.parse is smart enough to Do The Right Thing™. But notice how similar -- and easy -- it is to parse an XML document straight from the Internet.
 
    Example 10.2. Parsing XML from a URL
     >>> import urllib
 >>> usock = urllib.urlopen('http://slashdot.org/slashdot.rdf') 1
@@ -8050,13 +7573,13 @@ just going to be parsing a local file, you can pass the filename and minid
 
 1 
 
-As you saw in a previous chapter, urlopen takes a web page URL and returns a file-like object.  Most importantly, this object has a read method which returns the HTML source of the web page.
+As you saw in a previous chapter, urlopen takes a web page URL and returns a file-like object. Most importantly, this object has a read method which returns the HTML source of the web page.
 
 
 
 2 
 
-Now you pass the file-like object to minidom.parse, which obediently calls the read method of the object and parses the XML data that the read method returns.  The fact that this XML data is now coming straight from a web page is completely irrelevant.  minidom.parse doesn't know about web pages, and it doesn't care about web pages; it just knows about file-like objects.
+Now you pass the file-like object to minidom.parse, which obediently calls the read method of the object and parses the XML data that the read method returns. The fact that this XML data is now coming straight from a web page is completely irrelevant. minidom.parse doesn't know about web pages, and it doesn't care about web pages; it just knows about file-like objects.
 
 
 
@@ -8068,7 +7591,7 @@ just going to be parsing a local file, you can pass the filename and minid
 
 4 
 
-By the way, this URL is real, and it really is XML.  It's an XML representation of the current headlines on Slashdot, a technical news and gossip site.
+By the way, this URL is real, and it really is XML. It's an XML representation of the current headlines on Slashdot, a technical news and gossip site.
 
 
 
@@ -8082,13 +7605,13 @@ just going to be parsing a local file, you can pass the filename and minid
 
 1 
 
-minidom has a method, parseString, which takes an entire XML document as a string and parses it.  You can use this instead of minidom.parse if you know you already have your entire XML document in a string.
+minidom has a method, parseString, which takes an entire XML document as a string and parses it. You can use this instead of minidom.parse if you know you already have your entire XML document in a string.
 
 
 
-
    OK, so you can use the minidom.parse function for parsing both local files and remote URLs, but for parsing strings, you use... a different function.  That means that if you want to be able to take input from a
-file, a URL, or a string, you'll need special logic to check whether it's a string, and call the parseString function instead.  How unsatisfying.
-
    If there were a way to turn a string into a file-like object, then you could simply pass this object to minidom.parse.  And in fact, there is a module specifically designed for doing just that: StringIO.
+
    OK, so you can use the minidom.parse function for parsing both local files and remote URLs, but for parsing strings, you use... a different function. That means that if you want to be able to take input from a
+file, a URL, or a string, you'll need special logic to check whether it's a string, and call the parseString function instead. How unsatisfying.
+
    If there were a way to turn a string into a file-like object, then you could simply pass this object to minidom.parse. And in fact, there is a module specifically designed for doing just that: StringIO.
 
    Example 10.4. Introducing StringIO
     >>> contents = "<grammar><ref id='bit'><p>0</p><p>1</p></ref></grammar>"
 >>> import StringIO
@@ -8109,20 +7632,20 @@ file, a URL, or a string, you'll need special logic to check
 
 1 
 
-The StringIO module contains a single class, also called StringIO, which allows you to turn a string into a file-like object.  The StringIO class takes the string as a parameter when creating an instance.
+The StringIO module contains a single class, also called StringIO, which allows you to turn a string into a file-like object. The StringIO class takes the string as a parameter when creating an instance.
 
 
 
 2 
 
-Now you have a file-like object, and you can do all sorts of file-like things with it.  Like read, which returns the original string.
+Now you have a file-like object, and you can do all sorts of file-like things with it. Like read, which returns the original string.
 
 
 
 3 
 
-Calling read again returns an empty string.  This is how real file objects work too; once you read the entire file, you can't read any
-            more without explicitly seeking to the beginning of the file.  The StringIO object works the same way.
+Calling read again returns an empty string. This is how real file objects work too; once you read the entire file, you can't read any
+            more without explicitly seeking to the beginning of the file. The StringIO object works the same way.
 
 
 
@@ -8140,7 +7663,7 @@ file, a URL, or a string, you'll need special logic to check
 
 6 
 
-At any time, read will return the rest of the string that you haven't read yet.  All of this is exactly how file objects work; hence the term
+At any time, read will return the rest of the string that you haven't read yet. All of this is exactly how file objects work; hence the term
 file-like object.
 
 
@@ -8161,7 +7684,7 @@ file, a URL, or a string, you'll need special logic to check
 
 
 
-
    So now you know how to use a single function, minidom.parse, to parse an XML document stored on a web page, in a local file, or in a hard-coded string.  For a web page, you use urlopen to get a file-like object; for a local file, you use open; and for a string, you use StringIO.  Now let's take it one step further and generalize these differences as well.
+
    So now you know how to use a single function, minidom.parse, to parse an XML document stored on a web page, in a local file, or in a hard-coded string. For a web page, you use urlopen to get a file-like object; for a local file, you use open; and for a string, you use StringIO. Now let's take it one step further and generalize these differences as well.
 
    Example 10.6. openAnything
     def openAnything(source):1
     # try to open with urllib (if source is http, ftp, or file URL)
@@ -8184,26 +7707,26 @@ def openAnything(source):1 
 
-The openAnything function takes a single parameter, source, and returns a file-like object.  source is a string of some sort; it can either be a URL (like 'http://slashdot.org/slashdot.rdf'), a full or partial pathname to a local file (like 'binary.xml'), or a string that contains actual XML data to be parsed.
+The openAnything function takes a single parameter, source, and returns a file-like object. source is a string of some sort; it can either be a URL (like 'http://slashdot.org/slashdot.rdf'), a full or partial pathname to a local file (like 'binary.xml'), or a string that contains actual XML data to be parsed.
 
 
 
 2 
 
-First, you see if source is a URL.  You do this through brute force: you try to open it as a URL and silently ignore errors caused by trying to open something which is not a URL.  This is actually elegant in the sense that, if urllib ever supports new types of URLs in the future, you will also support them without recoding.  If urllib is able to open source, then the return kicks you out of the function immediately and the following try statements never execute.
+First, you see if source is a URL. You do this through brute force: you try to open it as a URL and silently ignore errors caused by trying to open something which is not a URL. This is actually elegant in the sense that, if urllib ever supports new types of URLs in the future, you will also support them without recoding. If urllib is able to open source, then the return kicks you out of the function immediately and the following try statements never execute.
 
 
 
 3 
 
-On the other hand, if urllib yelled at you and told you that source wasn't a valid URL, you assume it's a path to a file on disk and try to open it.  Again, you don't do anything fancy to check whether source is a valid filename or not (the rules for valid filenames vary wildly between different platforms anyway, so you'd probably
-            get them wrong anyway).  Instead, you just blindly open the file, and silently trap any errors.
+On the other hand, if urllib yelled at you and told you that source wasn't a valid URL, you assume it's a path to a file on disk and try to open it. Again, you don't do anything fancy to check whether source is a valid filename or not (the rules for valid filenames vary wildly between different platforms anyway, so you'd probably
+            get them wrong anyway). Instead, you just blindly open the file, and silently trap any errors.
 
 
 
 4 
 
-By this point, you need to assume that source is a string that has hard-coded data in it (since nothing else worked), so you use StringIO to create a file-like object out of it and return that.  (In fact, since you're using the str function, source doesn't even need to be a string; it could be any object, and you'll use its string representation, as defined by its __str__ special method.)
+By this point, you need to assume that source is a string that has hard-coded data in it (since nothing else worked), so you use StringIO to create a file-like object out of it and return that. (In fact, since you're using the str function, source doesn't even need to be a string; it could be any object, and you'll use its string representation, as defined by its __str__ special method.)
 
 
 
@@ -8215,23 +7738,23 @@ class KantGenerator:
         xmldoc = minidom.parse(sock).documentElement
         sock.close()
         return xmldoc
    10.2. Standard input, output, and error
    
-
    UNIX users are already familiar with the concept of standard input, standard output, and standard error.  This section is for
+
    UNIX users are already familiar with the concept of standard input, standard output, and standard error. This section is for
    the rest of you.
-
    Standard output and standard error (commonly abbreviated stdout and stderr) are pipes that are built into every UNIX system.  When you print something, it goes to the stdout pipe; when your program crashes and prints out debugging information (like a traceback in Python), it goes to the stderr pipe.  Both of these pipes are ordinarily just connected to the terminal window where you are working, so when a program
-prints, you see the output, and when a program crashes, you see the debugging information.  (If you're working on a system
+
    Standard output and standard error (commonly abbreviated stdout and stderr) are pipes that are built into every UNIX system. When you print something, it goes to the stdout pipe; when your program crashes and prints out debugging information (like a traceback in Python), it goes to the stderr pipe. Both of these pipes are ordinarily just connected to the terminal window where you are working, so when a program
+prints, you see the output, and when a program crashes, you see the debugging information. (If you're working on a system
 with a window-based Python IDE, stdout and stderr default to your “Interactive Window”.)
 
    Example 10.8. Introducing stdout and stderr
     >>> for i in range(3):
-...     print 'Dive in'             1
+...    print 'Dive in'             1
 Dive in
 Dive in
 Dive in
 >>> import sys
 >>> for i in range(3):
-...     sys.stdout.write('Dive in') 2
+...    sys.stdout.write('Dive in') 2
 Dive inDive inDive in
 >>> for i in range(3):
-...     sys.stderr.write('Dive in') 3
+...    sys.stderr.write('Dive in') 3
 Dive inDive inDive in
    
 
@@ -8243,17 +7766,17 @@ Dive inDive inDive in
    
 
    
-
-
    
 
    
 2 
 stdout is a file-like object; calling its write function will print out whatever string you give it.  In fact, this is what the print function really does; it adds a carriage return to the end of the string you're printing, and calls sys.stdout.write.
+stdout is a file-like object; calling its write function will print out whatever string you give it. In fact, this is what the print function really does; it adds a carriage return to the end of the string you're printing, and calls sys.stdout.write.
 
 
    
 
    
 3 
 In the simplest case, stdout and stderr send their output to the same place: the Python IDE (if you're in one), or the terminal (if you're running Python from the command line).  Like stdout, stderr does not add carriage returns for you; if you want them, add them yourself.
+In the simplest case, stdout and stderr send their output to the same place: the Python IDE (if you're in one), or the terminal (if you're running Python from the command line). Like stdout, stderr does not add carriage returns for you; if you want them, add them yourself.
 
 
    
 
    
-
    stdout and stderr are both file-like objects, like the ones you discussed in Section 10.1, “Abstracting input sources”, but they are both write-only.  They have no read method, only write.  Still, they are file-like objects, and you can assign any other file- or file-like object to them to redirect their output.
+
    stdout and stderr are both file-like objects, like the ones you discussed in Section 10.1, “Abstracting input sources”, but they are both write-only. They have no read method, only write. Still, they are file-like objects, and you can assign any other file- or file-like object to them to redirect their output.
 
    Example 10.9. Redirecting output
     [you@localhost kgp]$ python stdout.py
 Dive in
@@ -8287,7 +7810,7 @@ fsock.close()        7
 3 
 
-Open a file for writing.  If the file doesn't exist, it will be created.  If the file does exist, it will be overwritten.
+Open a file for writing. If the file doesn't exist, it will be created. If the file does exist, it will be overwritten.
 
 
 4 
@@ -8342,13 +7865,13 @@ raise Exception, 'this error will be logged' 3 
 
-Raise an exception.  Note from the screen output that this does not print anything on screen.  All the normal traceback information has been written to error.log.
+Raise an exception. Note from the screen output that this does not print anything on screen. All the normal traceback information has been written to error.log.
 
 
 
 4 
 
-Also note that you're not explicitly closing your log file, nor are you setting stderr back to its original value.  This is fine, since once the program crashes (because of the exception), Python will clean up and close the file for us, and it doesn't make any difference that stderr is never restored, since, as I mentioned, the program crashes and Python ends.  Restoring the original is more important for stdout, if you expect to go do other stuff within the same script afterwards.
+Also note that you're not explicitly closing your log file, nor are you setting stderr back to its original value. This is fine, since once the program crashes (because of the exception), Python will clean up and close the file for us, and it doesn't make any difference that stderr is never restored, since, as I mentioned, the program crashes and Python ends. Restoring the original is more important for stdout, if you expect to go do other stuff within the same script afterwards.
 
 
 
@@ -8365,13 +7888,13 @@ entering function
 
 1 
 
-This shorthand syntax of the print statement can be used to write to any open file, or file-like object.  In this case, you can redirect a single print statement to stderr without affecting subsequent print statements.
+This shorthand syntax of the print statement can be used to write to any open file, or file-like object. In this case, you can redirect a single print statement to stderr without affecting subsequent print statements.
 
 
 
 
    Standard input, on the other hand, is a read-only file object, and it represents the data flowing into the program from some
-previous program.  This will likely not make much sense to classic Mac OS users, or even Windows users unless you were ever fluent on the MS-DOS command line.  The way it works is that you can construct a chain of commands in a single line, so that one program's output
-becomes the input for the next program in the chain.  The first program simply outputs to standard output (without doing any
+previous program. This will likely not make much sense to classic Mac OS users, or even Windows users unless you were ever fluent on the MS-DOS command line. The way it works is that you can construct a chain of commands in a single line, so that one program's output
+becomes the input for the next program in the chain. The first program simply outputs to standard output (without doing any
 special redirecting itself, just doing normal print statements or whatever), and the next program reads from standard input, and the operating system takes care of connecting
 one program's output to the next program's input.
 
    Example 10.12. Chaining commands
    @@ -8402,24 +7925,24 @@ one program's output to the next program's input.
 
 2 
 
-This simply prints out the entire contents of binary.xml.  (Windows users should use type instead of cat.)
+This simply prints out the entire contents of binary.xml. (Windows users should use type instead of cat.)
 
 
 
 3 
 
-This prints the contents of binary.xml, but the “|” character, called the “pipe” character, means that the contents will not be printed to the screen.  Instead, they will become the standard input of the
+This prints the contents of binary.xml, but the “|” character, called the “pipe” character, means that the contents will not be printed to the screen. Instead, they will become the standard input of the
             next command, which in this case calls your Python script.
 
 
 
 4 
 
-Instead of specifying a module (like binary.xml), you specify “-”, which causes your script to load the grammar from standard input instead of from a specific file on disk.  (More on how
+Instead of specifying a module (like binary.xml), you specify “-”, which causes your script to load the grammar from standard input instead of from a specific file on disk. (More on how
             this happens in the next example.)  So the effect is the same as the first syntax, where you specified the grammar filename
-            directly, but think of the expansion possibilities here.  Instead of simply doing cat binary.xml, you could run a script that dynamically generates the grammar, then you can pipe it into your script.  It could come from
-            anywhere: a database, or some grammar-generating meta-script, or whatever.  The point is that you don't need to change your
-kgp.py script at all to incorporate any of this functionality.  All you need to do is be able to take grammar files from standard
+            directly, but think of the expansion possibilities here. Instead of simply doing cat binary.xml, you could run a script that dynamically generates the grammar, then you can pipe it into your script. It could come from
+            anywhere: a database, or some grammar-generating meta-script, or whatever. The point is that you don't need to change your
+kgp.py script at all to incorporate any of this functionality. All you need to do is be able to take grammar files from standard
             input, and you can separate all the other logic into another program.
 
 
@@ -8440,16 +7963,16 @@ def openAnything(source):
 
 1 
 
-This is the openAnything function from toolbox.py, which you previously examined in Section 10.1, “Abstracting input sources”.  All you've done is add three lines of code at the beginning of the function to check if the source is “-”; if so, you return sys.stdin.  Really, that's it!  Remember, stdin is a file-like object with a read method, so the rest of the code (in kgp.py, where you call openAnything) doesn't change a bit.
+This is the openAnything function from toolbox.py, which you previously examined in Section 10.1, “Abstracting input sources”. All you've done is add three lines of code at the beginning of the function to check if the source is “-”; if so, you return sys.stdin. Really, that's it!  Remember, stdin is a file-like object with a read method, so the rest of the code (in kgp.py, where you call openAnything) doesn't change a bit.
 
 
 
 
    10.3. Caching node lookups
    
-
    kgp.py employs several tricks which may or may not be useful to you in your XML processing.  The first one takes advantage of the consistent structure of the input documents to build a cache of nodes.
-
    A grammar file defines a series of ref elements.  Each ref contains one or more p elements, which can contain a lot of different things, including xrefs.  Whenever you encounter an xref, you look for a corresponding ref element with the same id attribute, and choose one of the ref element's children and parse it.  (You'll see how this random choice is made in the next section.)
-
    This is how you build up the grammar: define ref elements for the smallest pieces, then define ref elements which "include" the first ref elements by using xref, and so forth.  Then you parse the "largest" reference and follow each xref, and eventually output real text.  The text you output depends on the (random) decisions you make each time you fill in an
+
    kgp.py employs several tricks which may or may not be useful to you in your XML processing. The first one takes advantage of the consistent structure of the input documents to build a cache of nodes.
+
    A grammar file defines a series of ref elements. Each ref contains one or more p elements, which can contain a lot of different things, including xrefs. Whenever you encounter an xref, you look for a corresponding ref element with the same id attribute, and choose one of the ref element's children and parse it. (You'll see how this random choice is made in the next section.)
+
    This is how you build up the grammar: define ref elements for the smallest pieces, then define ref elements which "include" the first ref elements by using xref, and so forth. Then you parse the "largest" reference and follow each xref, and eventually output real text. The text you output depends on the (random) decisions you make each time you fill in an
 xref, so the output is different each time.
-
    This is all very flexible, but there is one downside: performance.  When you find an xref and need to find the corresponding ref element, you have a problem.  The xref has an id attribute, and you want to find the ref element that has that same id attribute, but there is no easy way to do that.  The slow way to do it would be to get the entire list of ref elements each time, then manually loop through and look at each id attribute.  The fast way is to do that once and build a cache, in the form of a dictionary.
+
    This is all very flexible, but there is one downside: performance. When you find an xref and need to find the corresponding ref element, you have a problem. The xref has an id attribute, and you want to find the ref element that has that same id attribute, but there is no easy way to do that. The slow way to do it would be to get the entire list of ref elements each time, then manually loop through and look at each id attribute. The fast way is to do that once and build a cache, in the form of a dictionary.
 
    Example 10.14. loadGrammar
         def loadGrammar(self, grammar):       
         self.grammar = self._load(grammar)
@@ -8466,19 +7989,19 @@ def openAnything(source):
 
 2 
 
-As you saw in Section 9.5, “Searching for elements”, getElementsByTagName returns a list of all the elements of a particular name.  You easily can get a list of all the ref elements, then simply loop through that list.
+As you saw in Section 9.5, “Searching for elements”, getElementsByTagName returns a list of all the elements of a particular name. You easily can get a list of all the ref elements, then simply loop through that list.
 
 
 
 3 
 
-As you saw in Section 9.6, “Accessing element attributes”, you can access individual attributes of an element by name, using standard dictionary syntax.  So the keys of the self.refs dictionary will be the values of the id attribute of each ref element.
+As you saw in Section 9.6, “Accessing element attributes”, you can access individual attributes of an element by name, using standard dictionary syntax. So the keys of the self.refs dictionary will be the values of the id attribute of each ref element.
 
 
 
 4 
 
-The values of the self.refs dictionary will be the ref elements themselves.  As you saw in Section 9.3, “Parsing XML”, each element, each node, each comment, each piece of text in a parsed XML document is an object.
+The values of the self.refs dictionary will be the ref elements themselves. As you saw in Section 9.3, “Parsing XML”, each element, each node, each comment, each piece of text in a parsed XML document is an object.
 
 
 
@@ -8488,8 +8011,8 @@ def openAnything(source):
         id = node.attributes["id"].value
         self.parse(self.randomChildElement(self.refs[id]))
    You'll explore the randomChildElement function in the next section.
 
    10.4. Finding direct children of a node
    
-
    Another useful techique when parsing XML documents is finding all the direct child elements of a particular element.  For instance, in the grammar files, a ref element can have several p elements, each of which can contain many things, including other p elements.  You want to find just the p elements that are children of the ref, not p elements that are children of other p elements.
-
    You might think you could simply use getElementsByTagName for this, but you can't.  getElementsByTagName searches recursively and returns a single list for all the elements it finds.  Since p elements can contain other p elements, you can't use getElementsByTagName, because it would return nested p elements that you don't want.  To find only direct child elements, you'll need to do it yourself.
+
    Another useful techique when parsing XML documents is finding all the direct child elements of a particular element. For instance, in the grammar files, a ref element can have several p elements, each of which can contain many things, including other p elements. You want to find just the p elements that are children of the ref, not p elements that are children of other p elements.
+
    You might think you could simply use getElementsByTagName for this, but you can't. getElementsByTagName searches recursively and returns a single list for all the elements it finds. Since p elements can contain other p elements, you can't use getElementsByTagName, because it would return nested p elements that you don't want. To find only direct child elements, you'll need to do it yourself.
 
    Example 10.16. Finding direct child elements
         def randomChildElement(self, node):
         choices = [e for e in node.childNodes
@@ -8506,26 +8029,26 @@ def openAnything(source):
 
 2 
 
-However, as you saw in Example 9.11, “Child nodes can be text”, the list returned by childNodes contains all different types of nodes, including text nodes.  That's not what you're looking for here.  You only want the
+However, as you saw in Example 9.11, “Child nodes can be text”, the list returned by childNodes contains all different types of nodes, including text nodes. That's not what you're looking for here. You only want the
             children that are elements.
 
 
 
 3 
 
-Each node has a nodeType attribute, which can be ELEMENT_NODE, TEXT_NODE, COMMENT_NODE, or any number of other values.  The complete list of possible values is in the __init__.py file in the xml.dom package.  (See Section 9.2, “Packages” for more on packages.)  But you're just interested in nodes that are elements, so you can filter the list to only include
+Each node has a nodeType attribute, which can be ELEMENT_NODE, TEXT_NODE, COMMENT_NODE, or any number of other values. The complete list of possible values is in the __init__.py file in the xml.dom package. (See Section 9.2, “Packages” for more on packages.)  But you're just interested in nodes that are elements, so you can filter the list to only include
             those nodes whose nodeType is ELEMENT_NODE.
 
 
 
 4 
 
-Once you have a list of actual elements, choosing a random one is easy.  Python comes with a module called random which includes several useful functions.  The random.choice function takes a list of any number of items and returns a random item.  For example, if the ref elements contains several p elements, then choices would be a list of p elements, and chosen would end up being assigned exactly one of them, selected at random.
+Once you have a list of actual elements, choosing a random one is easy. Python comes with a module called random which includes several useful functions. The random.choice function takes a list of any number of items and returns a random item. For example, if the ref elements contains several p elements, then choices would be a list of p elements, and chosen would end up being assigned exactly one of them, selected at random.
 
 
 
 
    10.5. Creating separate handlers by node type
    
-
    The third useful XML processing tip involves separating your code into logical functions, based on node types and element names.  Parsed XML documents are made up of various types of nodes, each represented by a Python object.  The root level of the document itself is represented by a Document object.  The Document then contains one or more Element objects (for actual XML tags), each of which may contain other Element objects, Text objects (for bits of text), or Comment objects (for embedded comments).  Python makes it easy to write a dispatcher to separate the logic for each node type.
+
    The third useful XML processing tip involves separating your code into logical functions, based on node types and element names. Parsed XML documents are made up of various types of nodes, each represented by a Python object. The root level of the document itself is represented by a Document object. The Document then contains one or more Element objects (for actual XML tags), each of which may contain other Element objects, Text objects (for bits of text), or Comment objects (for embedded comments). Python makes it easy to write a dispatcher to separate the logic for each node type.
 
    Example 10.17. Class names of parsed XML objects
     >>> from xml.dom import minidom
 >>> xmldoc = minidom.parse('kant.xml') 1
@@ -8545,18 +8068,18 @@ def openAnything(source):
 
 2 
 
-As you saw in Section 9.2, “Packages”, the object returned by parsing an XML document is a Document object, as defined in the minidom.py in the xml.dom package.  As you saw in Section 5.4, “Instantiating Classes”, __class__ is built-in attribute of every Python object.
+As you saw in Section 9.2, “Packages”, the object returned by parsing an XML document is a Document object, as defined in the minidom.py in the xml.dom package. As you saw in Section 5.4, “Instantiating Classes”, __class__ is built-in attribute of every Python object.
 
 
 
 3 
 
-Furthermore, __name__ is a built-in attribute of every Python class, and it is a string.  This string is not mysterious; it's the same as the class name you type when you define a class
-            yourself.  (See Section 5.3, “Defining Classes”.)
+Furthermore, __name__ is a built-in attribute of every Python class, and it is a string. This string is not mysterious; it's the same as the class name you type when you define a class
+            yourself. (See Section 5.3, “Defining Classes”.)
 
 
 
-
    Fine, so now you can get the class name of any particular XML node (since each XML node is represented as a Python object).  How can you use this to your advantage to separate the logic of parsing each node type?  The answer is getattr, which you first saw in Section 4.4, “Getting Object References With getattr”.
+
    Fine, so now you can get the class name of any particular XML node (since each XML node is represented as a Python object). How can you use this to your advantage to separate the logic of parsing each node type?  The answer is getattr, which you first saw in Section 4.4, “Getting Object References With getattr”.
 
    Example 10.18. parse, a generic XML node dispatcher
         def parse(self, node):          
         parseMethod = getattr(self, "parse_%s" % node.__class__.__name__) 1 2
@@ -8565,7 +8088,7 @@ def openAnything(source):
 
 1 
 
-First off, notice that you're constructing a larger string based on the class name of the node you were passed (in the node argument).  So if you're passed a Document node, you're constructing the string 'parse_Document', and so forth.
+First off, notice that you're constructing a larger string based on the class name of the node you were passed (in the node argument). So if you're passed a Document node, you're constructing the string 'parse_Document', and so forth.
 
 
 
@@ -8576,7 +8099,7 @@ def openAnything(source):
 
 3 
 
-Finally, you can call that function and pass the node itself as an argument.  The next example shows the definitions of each
+Finally, you can call that function and pass the node itself as an argument. The next example shows the definitions of each
             of these functions.
 
 
@@ -8604,39 +8127,39 @@ def openAnything(source):
 
 1 
 
-parse_Document is only ever called once, since there is only one Document node in an XML document, and only one Document object in the parsed XML representation.  It simply turns around and parses the root element of the grammar file.
+parse_Document is only ever called once, since there is only one Document node in an XML document, and only one Document object in the parsed XML representation. It simply turns around and parses the root element of the grammar file.
 
 
 
 2 
 
-parse_Text is called on nodes that represent bits of text.  The function itself does some special processing to handle automatic capitalization
+parse_Text is called on nodes that represent bits of text. The function itself does some special processing to handle automatic capitalization
             of the first word of a sentence, but otherwise simply appends the represented text to a list.
 
 
 
 3 
 
-parse_Comment is just a pass, since you don't care about embedded comments in the grammar files.  Note, however, that you still need to define the function
-            and explicitly make it do nothing.  If the function did not exist, the generic parse function would fail as soon as it stumbled on a comment, because it would try to find the non-existent parse_Comment function.  Defining a separate function for every node type, even ones you don't use, allows the generic parse function to stay simple and dumb.
+parse_Comment is just a pass, since you don't care about embedded comments in the grammar files. Note, however, that you still need to define the function
+            and explicitly make it do nothing. If the function did not exist, the generic parse function would fail as soon as it stumbled on a comment, because it would try to find the non-existent parse_Comment function. Defining a separate function for every node type, even ones you don't use, allows the generic parse function to stay simple and dumb.
 
 
 
 4 
 
-The parse_Element method is actually itself a dispatcher, based on the name of the element's tag.  The basic idea is the same: take what distinguishes
-            elements from each other (their tag names) and dispatch to a separate function for each of them.  You construct a string like
-'do_xref' (for an <xref> tag), find a function of that name, and call it.  And so forth for each of the other tag names that might be found in the
+The parse_Element method is actually itself a dispatcher, based on the name of the element's tag. The basic idea is the same: take what distinguishes
+            elements from each other (their tag names) and dispatch to a separate function for each of them. You construct a string like
+'do_xref' (for an <xref> tag), find a function of that name, and call it. And so forth for each of the other tag names that might be found in the
             course of parsing a grammar file (<p> tags, <choice> tags).
 
 
 
-
    In this example, the dispatch functions parse and parse_Element simply find other methods in the same class.  If your processing is very complex (or you have many different tag names),
+
    In this example, the dispatch functions parse and parse_Element simply find other methods in the same class. If your processing is very complex (or you have many different tag names),
 you could break up your code into separate modules, and use dynamic importing to import each module and call whatever functions
-you needed.  Dynamic importing will be discussed in Chapter 16, Functional Programming.
+you needed. Dynamic importing will be discussed in Chapter 16, Functional Programming.
 
    10.6. Handling command-line arguments
    
 
    Python fully supports creating programs that can be run on the command line, complete with command-line arguments and either short-
-   or long-style flags to specify various options.  None of this is XML-specific, but this script makes good use of command-line processing, so it seemed like a good time to mention it.
+   or long-style flags to specify various options. None of this is XML-specific, but this script makes good use of command-line processing, so it seemed like a good time to mention it.
 
    It's difficult to talk about command-line processing without understanding how command-line arguments are exposed to your
 Python program, so let's write a simple program to see them.
 
    Example 10.20. Introducing sys.argv
    
@@ -8650,7 +8173,7 @@ for arg in sys.argv: 
 1 
 
-Each command-line argument passed to the program will be in sys.argv, which is just a list.  Here you are printing each argument on a separate line.
+Each command-line argument passed to the program will be in sys.argv, which is just a list. Here you are printing each argument on a separate line.
 
 
 
@@ -8672,8 +8195,8 @@ kant.xml
    
 
 1 
 
-The first thing to know about sys.argv is that it contains the name of the script you're calling.  You will actually use this knowledge to your advantage later,
-            in Chapter 16, Functional Programming.  Don't worry about it for now.
+The first thing to know about sys.argv is that it contains the name of the script you're calling. You will actually use this knowledge to your advantage later,
+            in Chapter 16, Functional Programming. Don't worry about it for now.
 
 
 
@@ -8691,14 +8214,14 @@ kant.xml
    
 
 4 
 
-To make things even more interesting, some command-line flags themselves take arguments.  For instance, here you have a flag
-            (-m) which takes an argument (kant.xml).  Both the flag itself and the flag's argument are simply sequential elements in the sys.argv list.  No attempt is made to associate one with the other; all you get is a list.
+To make things even more interesting, some command-line flags themselves take arguments. For instance, here you have a flag
+            (-m) which takes an argument (kant.xml). Both the flag itself and the flag's argument are simply sequential elements in the sys.argv list. No attempt is made to associate one with the other; all you get is a list.
 
 
 
 
    So as you can see, you certainly have all the information passed on the command line, but then again, it doesn't look like
-it's going to be all that easy to actually use it.  For simple programs that only take a single argument and have no flags,
-you can simply use sys.argv[1] to access the argument.  There's no shame in this; I do it all the time.  For more complex programs, you need the getopt module.
+it's going to be all that easy to actually use it. For simple programs that only take a single argument and have no flags,
+you can simply use sys.argv[1] to access the argument. There's no shame in this; I do it all the time. For more complex programs, you need the getopt module.
 
    Example 10.22. Introducing getopt
     def main(argv):       
     grammar = "kant.xml"                 1
@@ -8716,34 +8239,34 @@ if __name__ == "__main__":
 
 1 
 
-First off, look at the bottom of the example and notice that you're calling the main function with sys.argv[1:].  Remember, sys.argv[0] is the name of the script that you're running; you don't care about that for command-line processing, so you chop it off
+First off, look at the bottom of the example and notice that you're calling the main function with sys.argv[1:]. Remember, sys.argv[0] is the name of the script that you're running; you don't care about that for command-line processing, so you chop it off
             and pass the rest of the list.
 
 
 
 2 
 
-This is where all the interesting processing happens.  The getopt function of the getopt module takes three parameters: the argument list (which you got from sys.argv[1:]), a string containing all the possible single-character command-line flags that this program accepts, and a list of longer
-            command-line flags that are equivalent to the single-character versions.  This is quite confusing at first glance, and is
+This is where all the interesting processing happens. The getopt function of the getopt module takes three parameters: the argument list (which you got from sys.argv[1:]), a string containing all the possible single-character command-line flags that this program accepts, and a list of longer
+            command-line flags that are equivalent to the single-character versions. This is quite confusing at first glance, and is
             explained in more detail below.
 
 
 
 3 
 
-If anything goes wrong trying to parse these command-line flags, getopt will raise an exception, which you catch.  You told getopt all the flags you understand, so this probably means that the end user passed some command-line flag that you don't understand.
+If anything goes wrong trying to parse these command-line flags, getopt will raise an exception, which you catch. You told getopt all the flags you understand, so this probably means that the end user passed some command-line flag that you don't understand.
 
 
 
 4 
 
 As is standard practice in the UNIX world, when the script is passed flags it doesn't understand, you print out a summary of proper usage and exit gracefully.
-             Note that I haven't shown the usage function here.  You would still need to code that somewhere and have it print out the appropriate summary; it's not automatic.
+             Note that I haven't shown the usage function here. You would still need to code that somewhere and have it print out the appropriate summary; it's not automatic.
 
 
 
 
    So what are all those parameters you pass to the getopt function?  Well, the first one is simply the raw list of command-line flags and arguments (not including the first element,
-the script name, which you already chopped off before calling the main function).  The second is the list of short command-line flags that the script accepts.
+the script name, which you already chopped off before calling the main function). The second is the list of short command-line flags that the script accepts.
 
    
 
    "hg:d"
    
 
    
@@ -8755,9 +8278,9 @@ the script name, which you already chopped off before calling the mainshow debugging information while parsing
 
    
 
    The first and third flags are simply standalone flags; you specify them or you don't, and they do things (print help) or change
-state (turn on debugging).  However, the second flag (-g) must be followed by an argument, which is the name of the grammar file to read from.  In fact it can be a filename or a web address,
-and you don't know which yet (you'll figure it out later), but you know it has to be something.  So you tell getopt this by putting a colon after the g in that second parameter to the getopt function.
-
    To further complicate things, the script accepts either short flags (like -h) or long flags (like --help), and you want them to do the same thing.  This is what the third parameter to getopt is for, to specify a list of the long flags that correspond to the short flags you specified in the second parameter.
+state (turn on debugging). However, the second flag (-g) must be followed by an argument, which is the name of the grammar file to read from. In fact it can be a filename or a web address,
+and you don't know which yet (you'll figure it out later), but you know it has to be something. So you tell getopt this by putting a colon after the g in that second parameter to the getopt function.
+
    To further complicate things, the script accepts either short flags (like -h) or long flags (like --help), and you want them to do the same thing. This is what the third parameter to getopt is for, to specify a list of the long flags that correspond to the short flags you specified in the second parameter.
 
    
 
    ["help", "grammar="]
    
 
    
@@ -8769,11 +8292,11 @@ and you don't know which yet (you'll figure it out later), but you know it has t
 
    Three things of note here:
 
    
 
      
-
    1. All long flags are preceded by two dashes on the command line, but you don't include those dashes when calling getopt.  They are understood.
+
    2. All long flags are preceded by two dashes on the command line, but you don't include those dashes when calling getopt. They are understood.
 
-
    3. The --grammar flag must always be followed by an additional argument, just like the -g flag.  This is notated by an equals sign, "grammar=".
+
    4. The --grammar flag must always be followed by an additional argument, just like the -g flag. This is notated by an equals sign, "grammar=".
 
-
    5. The list of long flags is shorter than the list of short flags, because the -d flag does not have a corresponding long version.  This is fine; only -d will turn on debugging.  But the order of short and long flags needs to be the same, so you'll need to specify all the short
+
    6. The list of long flags is shorter than the list of short flags, because the -d flag does not have a corresponding long version. This is fine; only -d will turn on debugging. But the order of short and long flags needs to be the same, so you'll need to specify all the short
       flags that do have corresponding long flags first, then all the rest of the short flags.
 
 
    
@@ -8804,28 +8327,28 @@ def main(argv):        
 1 
 
-The grammar variable will keep track of the grammar file you're using.  You initialize it here in case it's not specified on the command
+The grammar variable will keep track of the grammar file you're using. You initialize it here in case it's not specified on the command
             line (using either the -g or the --grammar flag).
 
 
 
 2 
 
-The opts variable that you get back from getopt contains a list of tuples: flag and argument.  If the flag doesn't take an argument, then arg will simply be None.  This makes it easier to loop through the flags.
+The opts variable that you get back from getopt contains a list of tuples: flag and argument. If the flag doesn't take an argument, then arg will simply be None. This makes it easier to loop through the flags.
 
 
 
 3 
 
 getopt validates that the command-line flags are acceptable, but it doesn't do any sort of conversion between short and long flags.
-             If you specify the -h flag, opt will contain "-h"; if you specify the --help flag, opt will contain "--help".  So you need to check for both.
+             If you specify the -h flag, opt will contain "-h"; if you specify the --help flag, opt will contain "--help". So you need to check for both.
 
 
 
 4 
 
-Remember, the -d flag didn't have a corresponding long flag, so you only need to check for the short form.  If you find it, you set a global
-            variable that you'll refer to later to print out debugging information.  (I used this during the development of the script.
+Remember, the -d flag didn't have a corresponding long flag, so you only need to check for the short form. If you find it, you set a global
+            variable that you'll refer to later to print out debugging information. (I used this during the development of the script.
              What, you thought all these examples worked on the first try?)
 
 
@@ -8838,14 +8361,14 @@ def main(argv):        
 6 
 
-That's it.  You've looped through and dealt with all the command-line flags.  That means that anything left must be command-line
-            arguments.  These come back from the getopt function in the args variable.  In this case, you're treating them as source material for the parser.  If there are no command-line arguments
+That's it. You've looped through and dealt with all the command-line flags. That means that anything left must be command-line
+            arguments. These come back from the getopt function in the args variable. In this case, you're treating them as source material for the parser. If there are no command-line arguments
             specified, args will be an empty list, and source will end up as the empty string.
 
 
 
 
    10.7. Putting it all together
    
-
    You've covered a lot of ground.  Let's step back and see how all the pieces fit together.
+
    You've covered a lot of ground. Let's step back and see how all the pieces fit together.
 
    To start with, this is a script that takes its arguments on the command line, using the getopt module.
 
     def main(argv):       
@@ -8857,7 +8380,7 @@ def main(argv):
     for opt, arg in opts:               
 ...
    You create a new instance of the KantGenerator class, and pass it the grammar file and source that may or may not have been specified on the command line.
 
    -    k = KantGenerator(grammar, source)
    The KantGenerator instance automatically loads the grammar, which is an XML file.  You use your custom openAnything function to open the file (which could be stored in a local file or a remote web server), then use the built-in minidom parsing functions to parse the XML into a tree of Python objects.
+    k = KantGenerator(grammar, source)
    The KantGenerator instance automatically loads the grammar, which is an XML file. You use your custom openAnything function to open the file (which could be stored in a local file or a remote web server), then use the built-in minidom parsing functions to parse the XML into a tree of Python objects.
 
         def _load(self, source):
         sock = toolbox.openAnything(source)
@@ -8875,7 +8398,7 @@ the "top-level" reference (that isn't referenced by anything else) and use that
             xrefs[xref.attributes["id"].value] = 1
         xrefs = xrefs.keys()
         standaloneXrefs = [e for e in self.refs.keys() if e not in xrefs]
-        return '<xref id="%s"/>' % random.choice(standaloneXrefs)
    Now you rip through the source material.  The source material is also XML, and you parse it one node at a time.  To keep the code separated and more maintainable, you use separate handlers for each node type.
+        return '<xref id="%s"/>' % random.choice(standaloneXrefs)
    Now you rip through the source material. The source material is also XML, and you parse it one node at a time. To keep the code separated and more maintainable, you use separate handlers for each node type.
 
         def parse_Element(self, node): 
         handlerMethod = getattr(self, "do_%s" % node.tagName)
@@ -8902,7 +8425,7 @@ def main(argv):
 ...
     k = KantGenerator(grammar, source)
     print k.output()
    10.8. Summary
    
-
    Python comes with powerful libraries for parsing and manipulating XML documents.  The minidom takes an XML file and parses it into Python objects, providing for random access to arbitrary elements.  Furthermore, this chapter shows how Python can be used to create a "real" standalone command-line script, complete with command-line flags, command-line arguments,
+
    Python comes with powerful libraries for parsing and manipulating XML documents. The minidom takes an XML file and parses it into Python objects, providing for random access to arbitrary elements. Furthermore, this chapter shows how Python can be used to create a "real" standalone command-line script, complete with command-line flags, command-line arguments,
    error handling, even the ability to take input from the piped result of a previous program.
 
    Before moving on to the next chapter, you should be comfortable doing all of these things:
 
    
@@ -8918,14 +8441,14 @@ def main(argv):
 
    11.1. Diving in
    
 
    You've learned about HTML processing and XML processing, and along the way you saw how to download a web page and how to parse XML from a URL, but let's dive into the more general topic of HTTP web services.
 
    Simply stated, HTTP web services are programmatic ways of sending and receiving data from remote servers using the operations
-of HTTP directly.  If you want to get data from the server, use a straight HTTP GET; if you want to send new data to the server,
-use HTTP POST.  (Some more advanced HTTP web service APIs also define ways of modifying existing data and deleting data, using
+of HTTP directly. If you want to get data from the server, use a straight HTTP GET; if you want to send new data to the server,
+use HTTP POST. (Some more advanced HTTP web service APIs also define ways of modifying existing data and deleting data, using
 HTTP PUT and HTTP DELETE.)  In other words, the “verbs” built into the HTTP protocol (GET, POST, PUT, and DELETE) map directly to application-level operations for receiving, sending,
 modifying, and deleting data.
-
    The main advantage of this approach is simplicity, and its simplicity has proven popular with a lot of different sites.  Data
+
    The main advantage of this approach is simplicity, and its simplicity has proven popular with a lot of different sites. Data
 -- usually XML data -- can be built and stored statically, or generated dynamically by a server-side script, and all major
-languages include an HTTP library for downloading it.  Debugging is also easier, because you can load up the web service in
-any web browser and see the raw data.  Modern browsers will even nicely format and pretty-print XML data for you, to allow
+languages include an HTTP library for downloading it. Debugging is also easier, because you can load up the web service in
+any web browser and see the raw data. Modern browsers will even nicely format and pretty-print XML data for you, to allow
 you to quickly navigate through it.
 
    Examples of pure XML-over-HTTP web services:
 
    
@@ -8940,7 +8463,7 @@ you to quickly navigate through it.
 
 
 
    In later chapters, you'll explore APIs which use HTTP as a transport for sending and receiving data, but don't map application
-semantics to the underlying HTTP semantics.  (They tunnel everything over HTTP POST.)  But this chapter will concentrate on
+semantics to the underlying HTTP semantics. (They tunnel everything over HTTP POST.)  But this chapter will concentrate on
 using HTTP GET to get data from a remote server, and you'll explore several HTTP features you can use to get the maximum benefit
 out of pure HTTP web services.
 
    Here is a more advanced version of the openanything module that you saw in the previous chapter:
@@ -8976,7 +8499,7 @@ def openAnything(source, etag=None, lastmodified=None, agent=USER_AGENT):
 
     This function lets you define parsers that take any input source
     (URL, pathname to local or network file, or actual data as a string)
-    and deal with it in a uniform manner.  Returned object is guaranteed
+    and deal with it in a uniform manner. Returned object is guaranteed
     to have all the basic stdio read methods (read, readline, readlines).
     Just .close() the object when you're done with it.
 
@@ -8985,7 +8508,7 @@ def openAnything(source, etag=None, lastmodified=None, agent=USER_AGENT):
 
     If the lastmodified argument is supplied, it must be a formatted
     date/time string in GMT (as returned in the Last-Modified header of
-    a previous request).  The formatted date/time will be used
+    a previous request). The formatted date/time will be used
     as the value of an If-Modified-Since request header.
 
     If the agent argument is supplied, it will be used as the value of a
@@ -9046,9 +8569,9 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 
 
 
    11.2. How not to fetch data over HTTP
    
-
    Let's say you want to download a resource over HTTP, such as a syndicated Atom feed.  But you don't just want to download
+
    Let's say you want to download a resource over HTTP, such as a syndicated Atom feed. But you don't just want to download
    it once; you want to download it over and over again, every hour, to get the latest news from the site that's offering the
-   news feed.  Let's do it the quick-and-dirty way first, and then see how you can do better.
+   news feed. Let's do it the quick-and-dirty way first, and then see how you can do better.
 
    Example 11.2. Downloading a feed the quick-and-dirty way
     >>> import urllib
 >>> data = urllib.urlopen('http://diveintomark.org/xml/atom.xml').read()    1
@@ -9066,13 +8589,13 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 
 1 
 
-Downloading anything over HTTP is incredibly easy in Python; in fact, it's a one-liner.  The urllib module has a handy urlopen function that takes the address of the page you want, and returns a file-like object that you can just read() from to get the full contents of the page.  It just can't get much easier.
+Downloading anything over HTTP is incredibly easy in Python; in fact, it's a one-liner. The urllib module has a handy urlopen function that takes the address of the page you want, and returns a file-like object that you can just read() from to get the full contents of the page. It just can't get much easier.
 
 
 
-
    So what's wrong with this?  Well, for a quick one-off during testing or development, there's nothing wrong with it.  I do
-it all the time.  I wanted the contents of the feed, and I got the contents of the feed.  The same technique works for any
-web page.  But once you start thinking in terms of a web service that you want to access on a regular basis -- and remember,
+
    So what's wrong with this?  Well, for a quick one-off during testing or development, there's nothing wrong with it. I do
+it all the time. I wanted the contents of the feed, and I got the contents of the feed. The same technique works for any
+web page. But once you start thinking in terms of a web service that you want to access on a regular basis -- and remember,
 you said you were planning on retrieving this syndicated feed once an hour -- then you're being inefficient, and you're being
 rude.
 
    Let's talk about some of the basic features of HTTP.
@@ -9080,54 +8603,54 @@ rude.
 
    There are five important features of HTTP which you should support.
 
    11.3.1. User-Agent
    
 
    The User-Agent is simply a way for a client to tell a server who it is when it requests a web page, a syndicated feed, or any sort of web
-   service over HTTP.  When the client requests a resource, it should always announce who it is, as specifically as possible.
+   service over HTTP. When the client requests a resource, it should always announce who it is, as specifically as possible.
    This allows the server-side administrator to get in touch with the client-side developer if anything is going fantastically
    wrong.
-
    By default, Python sends a generic User-Agent: Python-urllib/1.15.  In the next section, you'll see how to change this to something more specific.
+
    By default, Python sends a generic User-Agent: Python-urllib/1.15. In the next section, you'll see how to change this to something more specific.
 
    11.3.2. Redirects
    
-
    Sometimes resources move around.  Web sites get reorganized, pages move to new addresses.  Even web services can reorganize.
-   A syndicated feed at http://example.com/index.xml might be moved to http://example.com/xml/atom.xml.  Or an entire domain might move, as an organization expands and reorganizes; for instance, http://www.example.com/index.xml might be redirected to http://server-farm-1.example.com/index.xml.
-
    Every time you request any kind of resource from an HTTP server, the server includes a status code in its response.  Status
-   code 200 means “everything's normal, here's the page you asked for”.  Status code 404 means “page not found”.  (You've probably seen 404 errors while browsing the web.)
-
    HTTP has two different ways of signifying that a resource has moved.  Status code 302 is a temporary redirect; it means “oops, that got moved over here temporarily” (and then gives the temporary address in a Location: header).  Status code 301 is a permanent redirect; it means “oops, that got moved permanently” (and then gives the new address in a Location: header).  If you get a 302 status code and a new address, the HTTP specification says you should use the new address to get what you asked for, but
-   the next time you want to access the same resource, you should retry the old address.  But if you get a 301 status code and a new address, you're supposed to use the new address from then on.
+
    Sometimes resources move around. Web sites get reorganized, pages move to new addresses. Even web services can reorganize.
+   A syndicated feed at http://example.com/index.xml might be moved to http://example.com/xml/atom.xml. Or an entire domain might move, as an organization expands and reorganizes; for instance, http://www.example.com/index.xml might be redirected to http://server-farm-1.example.com/index.xml.
+
    Every time you request any kind of resource from an HTTP server, the server includes a status code in its response. Status
+   code 200 means “everything's normal, here's the page you asked for”. Status code 404 means “page not found”. (You've probably seen 404 errors while browsing the web.)
+
    HTTP has two different ways of signifying that a resource has moved. Status code 302 is a temporary redirect; it means “oops, that got moved over here temporarily” (and then gives the temporary address in a Location: header). Status code 301 is a permanent redirect; it means “oops, that got moved permanently” (and then gives the new address in a Location: header). If you get a 302 status code and a new address, the HTTP specification says you should use the new address to get what you asked for, but
+   the next time you want to access the same resource, you should retry the old address. But if you get a 301 status code and a new address, you're supposed to use the new address from then on.
 
    urllib.urlopen will automatically “follow” redirects when it receives the appropriate status code from the HTTP server, but unfortunately, it doesn't tell you when
-   it does so.  You'll end up getting data you asked for, but you'll never know that the underlying library “helpfully” followed a redirect for you.  So you'll continue pounding away at the old address, and each time you'll get redirected to
-   the new address.  That's two round trips instead of one: not very efficient!  Later in this chapter, you'll see how to work
+   it does so. You'll end up getting data you asked for, but you'll never know that the underlying library “helpfully” followed a redirect for you. So you'll continue pounding away at the old address, and each time you'll get redirected to
+   the new address. That's two round trips instead of one: not very efficient!  Later in this chapter, you'll see how to work
    around this so you can deal with permanent redirects properly and efficiently.
 
    11.3.3. Last-Modified/If-Modified-Since
    
-
    Some data changes all the time.  The home page of CNN.com is constantly updating every few minutes.  On the other hand, the
+
    Some data changes all the time. The home page of CNN.com is constantly updating every few minutes. On the other hand, the
    home page of Google.com only changes once every few weeks (when they put up a special holiday logo, or advertise a new service).
    Web services are no different; usually the server knows when the data you requested last changed, and HTTP provides a way
    for the server to include this last-modified date along with the data you requested.
 
    If you ask for the same data a second time (or third, or fourth), you can tell the server the last-modified date that you
-   got last time: you send an If-Modified-Since header with your request, with the date you got back from the server last time.  If the data hasn't changed since then, the
-   server sends back a special HTTP status code 304, which means “this data hasn't changed since the last time you asked for it”.  Why is this an improvement?  Because when the server sends a 304, it doesn't re-send the data.  All you get is the status code.  So you don't need to download the same data over and over again if it hasn't changed;
+   got last time: you send an If-Modified-Since header with your request, with the date you got back from the server last time. If the data hasn't changed since then, the
+   server sends back a special HTTP status code 304, which means “this data hasn't changed since the last time you asked for it”. Why is this an improvement?  Because when the server sends a 304, it doesn't re-send the data. All you get is the status code. So you don't need to download the same data over and over again if it hasn't changed;
    the server assumes you have the data cached locally.
-
    All modern web browsers support last-modified date checking.  If you've ever visited a page, re-visited the same page a day
-   later and found that it hadn't changed, and wondered why it loaded so quickly the second time -- this could be why.  Your
+
    All modern web browsers support last-modified date checking. If you've ever visited a page, re-visited the same page a day
+   later and found that it hadn't changed, and wondered why it loaded so quickly the second time -- this could be why. Your
    web browser cached the contents of the page locally the first time, and when you visited the second time, your browser automatically
-   sent the last-modified date it got from the server the first time.  The server simply says 304: Not Modified, so your browser knows to load the page from its cache.  Web services can be this smart too.
+   sent the last-modified date it got from the server the first time. The server simply says 304: Not Modified, so your browser knows to load the page from its cache. Web services can be this smart too.
 
    Python's URL library has no built-in support for last-modified date checking, but since you can add arbitrary headers to each request
    and read arbitrary headers in each response, you can add support for it yourself.
 
    11.3.4. ETag/If-None-Match
    
 
    ETags are an alternate way to accomplish the same thing as the last-modified date checking: don't re-download data that hasn't
-   changed.  The way it works is, the server sends some sort of hash of the data (in an ETag header) along with the data you requested.  Exactly how this hash is determined is entirely up to the server.  The second
-   time you request the same data, you include the ETag hash in an If-None-Match: header, and if the data hasn't changed, the server will send you back a 304 status code.  As with the last-modified date checking, the server just sends the 304; it doesn't send you the same data a second time.  By including the ETag hash in your second request, you're telling the
+   changed. The way it works is, the server sends some sort of hash of the data (in an ETag header) along with the data you requested. Exactly how this hash is determined is entirely up to the server. The second
+   time you request the same data, you include the ETag hash in an If-None-Match: header, and if the data hasn't changed, the server will send you back a 304 status code. As with the last-modified date checking, the server just sends the 304; it doesn't send you the same data a second time. By including the ETag hash in your second request, you're telling the
    server that there's no need to re-send the same data if it still matches this hash, since you still have the data from the
    last time.
 
    Python's URL library has no built-in support for ETags, but you'll see how to add it later in this chapter.
 
    11.3.5. Compression
    
-
    The last important HTTP feature is gzip compression.  When you talk about HTTP web services, you're almost always talking
-   about moving XML back and forth over the wire.  XML is text, and quite verbose text at that, and text generally compresses
-   well.  When you request a resource over HTTP, you can ask the server that, if it has any new data to send you, to please send
-   it in compressed format.  You include the Accept-encoding: gzip header in your request, and if the server supports compression, it will send you back gzip-compressed data and mark it with
+
    The last important HTTP feature is gzip compression. When you talk about HTTP web services, you're almost always talking
+   about moving XML back and forth over the wire. XML is text, and quite verbose text at that, and text generally compresses
+   well. When you request a resource over HTTP, you can ask the server that, if it has any new data to send you, to please send
+   it in compressed format. You include the Accept-encoding: gzip header in your request, and if the server supports compression, it will send you back gzip-compressed data and mark it with
    a Content-encoding: gzip header.
-
    Python's URL library has no built-in support for gzip compression per se, but you can add arbitrary headers to the request.  And
+
    Python's URL library has no built-in support for gzip compression per se, but you can add arbitrary headers to the request. And
 Python comes with a separate gzip module, which has functions you can use to decompress the data yourself.
-
    Note that our little one-line script to download a syndicated feed did not support any of these HTTP features.  Let's see how you can improve it.
+
    Note that our little one-line script to download a syndicated feed did not support any of these HTTP features. Let's see how you can improve it.
 
    11.4. Debugging HTTP web services
    
-
    First, let's turn on the debugging features of Python's HTTP library and see what's being sent over the wire.  This will be useful throughout the chapter, as you add more and
+
    First, let's turn on the debugging features of Python's HTTP library and see what's being sent over the wire. This will be useful throughout the chapter, as you add more and
    more features.
 
    Example 11.3. Debugging HTTP
     >>> import httplib
@@ -9154,62 +8677,62 @@ header: Connection: close
 
 1 
 
-urllib relies on another standard Python library, httplib.  Normally you don't need to import httplib directly (urllib does that automatically), but you will here so you can set the debugging flag on the HTTPConnection class that urllib uses internally to connect to the HTTP server.  This is an incredibly useful technique.  Some other Python libraries have similar debug flags, but there's no particular standard for naming them or turning them on; you need to read
+urllib relies on another standard Python library, httplib. Normally you don't need to import httplib directly (urllib does that automatically), but you will here so you can set the debugging flag on the HTTPConnection class that urllib uses internally to connect to the HTTP server. This is an incredibly useful technique. Some other Python libraries have similar debug flags, but there's no particular standard for naming them or turning them on; you need to read
          the documentation of each library to see if such a feature is available.
 
 
 
 2 
 
-Now that the debugging flag is set, information on the the HTTP request and response is printed out in real time.  The first
+Now that the debugging flag is set, information on the the HTTP request and response is printed out in real time. The first
          thing it tells you is that you're connecting to the server diveintomark.org on port 80, which is the standard port for HTTP.
 
 
 
 3 
 
-When you request the Atom feed, urllib sends three lines to the server.  The first line specifies the HTTP verb you're using, and the path of the resource (minus
-         the domain name).  All the requests in this chapter will use GET, but in the next chapter on SOAP, you'll see that it uses POST for everything.  The basic syntax is the same, regardless of the verb.
+When you request the Atom feed, urllib sends three lines to the server. The first line specifies the HTTP verb you're using, and the path of the resource (minus
+         the domain name). All the requests in this chapter will use GET, but in the next chapter on SOAP, you'll see that it uses POST for everything. The basic syntax is the same, regardless of the verb.
 
 
 
 4 
 
-The second line is the Host header, which specifies the domain name of the service you're accessing.  This is important, because a single HTTP server
-         can host multiple separate domains.  My server currently hosts 12 domains; other servers can host hundreds or even thousands.
+The second line is the Host header, which specifies the domain name of the service you're accessing. This is important, because a single HTTP server
+         can host multiple separate domains. My server currently hosts 12 domains; other servers can host hundreds or even thousands.
 
 
 
 5 
 
-The third line is the User-Agent header.  What you see here is the generic User-Agent that the urllib library adds by default.  In the next section, you'll see how to customize this to be more specific.
+The third line is the User-Agent header. What you see here is the generic User-Agent that the urllib library adds by default. In the next section, you'll see how to customize this to be more specific.
 
 
 
 6 
 
-The server replies with a status code and a bunch of headers (and possibly some data, which got stored in the feeddata variable).  The status code here is 200, meaning “everything's normal, here's the data you requested”.  The server also tells you the date it responded to your request, some information about the server itself, and the content
-         type of the data it's giving you.  Depending on your application, this might be useful, or not.  It's certainly reassuring
+The server replies with a status code and a bunch of headers (and possibly some data, which got stored in the feeddata variable). The status code here is 200, meaning “everything's normal, here's the data you requested”. The server also tells you the date it responded to your request, some information about the server itself, and the content
+         type of the data it's giving you. Depending on your application, this might be useful, or not. It's certainly reassuring
          that you thought you were asking for an Atom feed, and lo and behold, you're getting an Atom feed (application/atom+xml, which is the registered content type for Atom feeds).
 
 
 
 7 
 
-The server tells you when this Atom feed was last modified (in this case, about 13 minutes ago).  You can send this date back
+The server tells you when this Atom feed was last modified (in this case, about 13 minutes ago). You can send this date back
          to the server the next time you request the same feed, and the server can do last-modified checking.
 
 
 
 8 
 
-The server also tells you that this Atom feed has an ETag hash of "e8284-68e0-4de30f80".  The hash doesn't mean anything by itself; there's nothing you can do with it, except send it back to the server the next
-         time you request this same feed.  Then the server can use it to tell you if the data has changed or not.
+The server also tells you that this Atom feed has an ETag hash of "e8284-68e0-4de30f80". The hash doesn't mean anything by itself; there's nothing you can do with it, except send it back to the server the next
+         time you request this same feed. Then the server can use it to tell you if the data has changed or not.
 
 
 
 
    11.5. Setting the User-Agent
    
-
    The first step to improving your HTTP web services client is to identify yourself properly with a User-Agent.  To do that, you need to move beyond the basic urllib and dive into urllib2.
+
    The first step to improving your HTTP web services client is to identify yourself properly with a User-Agent. To do that, you need to move beyond the basic urllib and dive into urllib2.
 
    Example 11.4. Introducing urllib2
     >>> import httplib
 >>> httplib.HTTPConnection.debuglevel = 1           1
@@ -9243,22 +8766,22 @@ header: Connection: close
 
 2 
 
-Fetching an HTTP resource with urllib2 is a three-step process, for good reasons that will become clear shortly.  The first step is to create a Request object, which takes the URL of the resource you'll eventually get around to retrieving.  Note that this step doesn't actually
+Fetching an HTTP resource with urllib2 is a three-step process, for good reasons that will become clear shortly. The first step is to create a Request object, which takes the URL of the resource you'll eventually get around to retrieving. Note that this step doesn't actually
             retrieve anything yet.
 
 
 
 3 
 
-The second step is to build a URL opener.  This can take any number of handlers, which control how responses are handled.
-             But you can also build an opener without any custom handlers, which is what you're doing here.  You'll see how to define
+The second step is to build a URL opener. This can take any number of handlers, which control how responses are handled.
+             But you can also build an opener without any custom handlers, which is what you're doing here. You'll see how to define
             and use custom handlers later in this chapter when you explore redirects.
 
 
 
 4 
 
-The final step is to tell the opener to open the URL, using the Request object you created.  As you can see from all the debugging information that gets printed, this step actually retrieves the
+The final step is to tell the opener to open the URL, using the Request object you created. As you can see from all the debugging information that gets printed, this step actually retrieves the
             resource and stores the returned data in feeddata.
 
 
@@ -9269,7 +8792,7 @@ header: Connection: close
 >>> request.get_full_url()
 http://diveintomark.org/xml/atom.xml
 >>> request.add_header('User-Agent',
-...     'OpenAnything/1.0 +http://diveintopython3.org/')    2
+...    'OpenAnything/1.0 +http://diveintopython3.org/')    2
 >>> feeddata = opener.open(request).read()                 3
 connect: (diveintomark.org, 80)
 send: '
@@ -9297,9 +8820,9 @@ header: Connection: close
 
 2 
 
-Using the add_header method on the Request object, you can add arbitrary HTTP headers to the request.  The first argument is the header, the second is the value you're
-            providing for that header.  Convention dictates that a User-Agent should be in this specific format: an application name, followed by a slash, followed by a version number.  The rest is free-form,
-            and you'll see a lot of variations in the wild, but somewhere it should include a URL of your application.  The User-Agent is usually logged by the server along with other details of your request, and including a URL of your application allows
+Using the add_header method on the Request object, you can add arbitrary HTTP headers to the request. The first argument is the header, the second is the value you're
+            providing for that header. Convention dictates that a User-Agent should be in this specific format: an application name, followed by a slash, followed by a version number. The rest is free-form,
+            and you'll see a lot of variations in the wild, but somewhere it should include a URL of your application. The User-Agent is usually logged by the server along with other details of your request, and including a URL of your application allows
             server administrators looking through their access logs to contact you if something is wrong.
 
 
@@ -9312,15 +8835,15 @@ header: Connection: close
 
 4 
 
-And here's you sending your custom User-Agent, in place of the generic one that Python sends by default.  If you look closely, you'll notice that you defined a User-Agent header, but you actually sent a User-agent header.  See the difference?  urllib2 changed the case so that only the first letter was capitalized.  It doesn't really matter; HTTP specifies that header field
+And here's you sending your custom User-Agent, in place of the generic one that Python sends by default. If you look closely, you'll notice that you defined a User-Agent header, but you actually sent a User-agent header. See the difference?  urllib2 changed the case so that only the first letter was capitalized. It doesn't really matter; HTTP specifies that header field
             names are completely case-insensitive.
 
 
 
 
    11.6. Handling Last-Modified and ETag
    
 
    Now that you know how to add custom HTTP headers to your web service requests, let's look at adding support for Last-Modified and ETag headers.
-
    These examples show the output with debugging turned off.  If you still have it turned on from the previous section, you can
-turn it off by setting httplib.HTTPConnection.debuglevel = 0.  Or you can just leave debugging on, if that helps you.
+
    These examples show the output with debugging turned off. If you still have it turned on from the previous section, you can
+turn it off by setting httplib.HTTPConnection.debuglevel = 0. Or you can just leave debugging on, if that helps you.
 
    Example 11.6. Testing Last-Modified
     >>> import urllib2
 >>> request = urllib2.Request('http://diveintomark.org/xml/atom.xml')
@@ -9336,7 +8859,7 @@ turn it off by setting httplib.HTTPConnection.debuglevel = 0.  Or y
  'accept-ranges': 'bytes', 
  'connection': 'close'}
 >>> request.add_header('If-Modified-Since',
-...     firstdatastream.headers.get('Last-Modified'))  2
+...    firstdatastream.headers.get('Last-Modified'))  2
 >>> seconddatastream = opener.open(request)            3
 Traceback (most recent call last):
   File "<stdin>", line 1, in ?
@@ -9367,20 +8890,20 @@ urllib2.HTTPError: HTTP Error 304: Not Modified
 
 2 
 
-On the second request, you add the If-Modified-Since header with the last-modified date from the first request.  If the data hasn't changed, the server should return a 304 status code.
+On the second request, you add the If-Modified-Since header with the last-modified date from the first request. If the data hasn't changed, the server should return a 304 status code.
 
 
 
 3 
 
-Sure enough, the data hasn't changed.  You can see from the traceback that urllib2 throws a special exception, HTTPError, in response to the 304 status code.  This is a little unusual, and not entirely helpful.  After all, it's not an error; you specifically asked the
+Sure enough, the data hasn't changed. You can see from the traceback that urllib2 throws a special exception, HTTPError, in response to the 304 status code. This is a little unusual, and not entirely helpful. After all, it's not an error; you specifically asked the
             server not to send you any data if it hadn't changed, and the data didn't change, so the server told you it wasn't sending
-            you any data.  That's not an error; that's exactly what you were hoping for.
+            you any data. That's not an error; that's exactly what you were hoping for.
 
 
 
-
    urllib2 also raises an HTTPError exception for conditions that you would think of as errors, such as 404 (page not found).  In fact, it will raise HTTPError for any status code other than 200 (OK), 301 (permanent redirect), or 302 (temporary redirect).  It would be more helpful for your purposes to capture the status code and simply return it, without
-throwing an exception.  To do that, you'll need to define a custom URL handler.
+
    urllib2 also raises an HTTPError exception for conditions that you would think of as errors, such as 404 (page not found). In fact, it will raise HTTPError for any status code other than 200 (OK), 301 (permanent redirect), or 302 (temporary redirect). It would be more helpful for your purposes to capture the status code and simply return it, without
+throwing an exception. To do that, you'll need to define a custom URL handler.
 
    Example 11.7. Defining URL handlers
    
 
    This custom URL handler is part of openanything.py.
     class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    1
@@ -9394,20 +8917,20 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    1 
 
-urllib2 is designed around URL handlers.  Each handler is just a class that can define any number of methods.  When something happens
-            -- like an HTTP error, or even a 304 code -- urllib2 introspects into the list of defined handlers for a method that can handle it.  You used a similar introspection in Chapter 9, XML Processing to define handlers for different node types, but urllib2 is more flexible, and introspects over as many handlers as are defined for the current request.
+urllib2 is designed around URL handlers. Each handler is just a class that can define any number of methods. When something happens
+            -- like an HTTP error, or even a 304 code -- urllib2 introspects into the list of defined handlers for a method that can handle it. You used a similar introspection in Chapter 9, XML Processing to define handlers for different node types, but urllib2 is more flexible, and introspects over as many handlers as are defined for the current request.
 
 
 
 2 
 
-urllib2 searches through the defined handlers and calls the http_error_default method when it encounters a 304 status code from the server. By defining a custom error handler, you can prevent urllib2 from raising an exception.  Instead, you create the HTTPError object, but return it instead of raising it.
+urllib2 searches through the defined handlers and calls the http_error_default method when it encounters a 304 status code from the server. By defining a custom error handler, you can prevent urllib2 from raising an exception. Instead, you create the HTTPError object, but return it instead of raising it.
 
 
 
 3 
 
-This is the key part: before returning, you save the status code returned by the HTTP server.  This will allow you easy access
+This is the key part: before returning, you save the status code returned by the HTTP server. This will allow you easy access
             to it from the calling program.
 
 
@@ -9417,7 +8940,7 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    >>> import openanything
 >>> opener = urllib2.build_opener(
-...     openanything.DefaultErrorHandler())   2
+...    openanything.DefaultErrorHandler())   2
 >>> seconddatastream = opener.open(request)
 >>> seconddatastream.status 3
 304
@@ -9434,30 +8957,30 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    2 
 
-This is the key: now that you've defined your custom URL handler, you need to tell urllib2 to use it.  Remember how I said that urllib2 broke up the process of accessing an HTTP resource into three steps, and for good reason?  This is why building the URL opener
+This is the key: now that you've defined your custom URL handler, you need to tell urllib2 to use it. Remember how I said that urllib2 broke up the process of accessing an HTTP resource into three steps, and for good reason?  This is why building the URL opener
             is its own step, because you can build it with your own custom URL handlers that override urllib2's default behavior.
 
 
 
 3 
 
-Now you can quietly open the resource, and what you get back is an object that, along with the usual headers (use seconddatastream.headers.dict to acess them), also contains the HTTP status code.  In this case, as you expected, the status is 304, meaning this data hasn't changed since the last time you asked for it.
+Now you can quietly open the resource, and what you get back is an object that, along with the usual headers (use seconddatastream.headers.dict to acess them), also contains the HTTP status code. In this case, as you expected, the status is 304, meaning this data hasn't changed since the last time you asked for it.
 
 
 
 4 
 
-Note that when the server sends back a 304 status code, it doesn't re-send the data.  That's the whole point: to save bandwidth by not re-downloading data that hasn't
-            changed.  So if you actually want that data, you'll need to cache it locally the first time you get it.
+Note that when the server sends back a 304 status code, it doesn't re-send the data. That's the whole point: to save bandwidth by not re-downloading data that hasn't
+            changed. So if you actually want that data, you'll need to cache it locally the first time you get it.
 
 
 
-
    Handling ETag works much the same way, but instead of checking for Last-Modified and sending If-Modified-Since, you check for ETag and send If-None-Match.  Let's start with a fresh IDE session.
+
    Handling ETag works much the same way, but instead of checking for Last-Modified and sending If-Modified-Since, you check for ETag and send If-None-Match. Let's start with a fresh IDE session.
 
    Example 11.9. Supporting ETag/If-None-Match
     >>> import urllib2, openanything
 >>> request = urllib2.Request('http://diveintomark.org/xml/atom.xml')
 >>> opener = urllib2.build_opener(
-...     openanything.DefaultErrorHandler())
+...    openanything.DefaultErrorHandler())
 >>> firstdatastream = opener.open(request)
 >>> firstdatastream.headers.get('ETag')        1
 '"e842a-3e53-55d97640"'
@@ -9472,7 +8995,7 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    
   <-- rest of feed omitted for brevity -->
 >>> request.add_header('If-None-Match',
-...     firstdatastream.headers.get('ETag'))   3
+...    firstdatastream.headers.get('ETag'))   3
 >>> seconddatastream = opener.open(request)
 >>> seconddatastream.status  4
 304
@@ -9483,7 +9006,7 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    1 
 
-Using the firstdatastream.headers pseudo-dictionary, you can get the ETag returned from the server.  (What happens if the server didn't send back an ETag?  Then this line would return None.)
+Using the firstdatastream.headers pseudo-dictionary, you can get the ETag returned from the server. (What happens if the server didn't send back an ETag?  Then this line would return None.)
 
 
 
@@ -9500,13 +9023,13 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    4 
 
-The second call succeeds quietly (without throwing an exception), and once again you see that the server has sent back a 304 status code.  Based on the ETag you sent the second time, it knows that the data hasn't changed.
+The second call succeeds quietly (without throwing an exception), and once again you see that the server has sent back a 304 status code. Based on the ETag you sent the second time, it knows that the data hasn't changed.
 
 
 
 5 
 
-Regardless of whether the 304 is triggered by Last-Modified date checking or ETag hash matching, you'll never get the data along with the 304.  That's the whole point.
+Regardless of whether the 304 is triggered by Last-Modified date checking or ETag hash matching, you'll never get the data along with the 304. That's the whole point.
 
 
 
@@ -9515,7 +9038,7 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    Note
 
 
-In these examples, the HTTP server has supported both Last-Modified and ETag headers, but not all servers do.  As a web services client, you should be prepared to support both, but you must code defensively
+In these examples, the HTTP server has supported both Last-Modified and ETag headers, but not all servers do. As a web services client, you should be prepared to support both, but you must code defensively
       in case a server only supports one or the other, or neither.
 
 
@@ -9527,7 +9050,7 @@ class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):    >>> import urllib2, httplib
 >>> httplib.HTTPConnection.debuglevel = 1           1
 >>> request = urllib2.Request(
-...     'http://diveintomark.org/redir/example301.xml') 2
+...    'http://diveintomark.org/redir/example301.xml') 2
 >>> opener = urllib2.build_opener()
 >>> f = opener.open(request)
 connect: (diveintomark.org, 80)
@@ -9608,14 +9131,14 @@ AttributeError: addinfourl instance has no attribute 'status'
 6 
 
 The object you get back from the opener contains the new permanent address and all the headers returned from the second request (retrieved from the new permanent
-            address).  But the status code is missing, so you have no way of knowing programmatically whether this redirect was temporary
-            or permanent.  And that matters very much: if it was a temporary redirect, then you should continue to ask for the data at
-            the old location.  But if it was a permanent redirect (as this was), you should ask for the data at the new location from
+            address). But the status code is missing, so you have no way of knowing programmatically whether this redirect was temporary
+            or permanent. And that matters very much: if it was a temporary redirect, then you should continue to ask for the data at
+            the old location. But if it was a permanent redirect (as this was), you should ask for the data at the new location from
             now on.
 
 
 
-
    This is suboptimal, but easy to fix.  urllib2 doesn't behave exactly as you want it to when it encounters a 301 or 302, so let's override its behavior.  How?  With a custom URL handler, just like you did to handle 304 codes.
+
    This is suboptimal, but easy to fix. urllib2 doesn't behave exactly as you want it to when it encounters a 301 or 302, so let's override its behavior. How?  With a custom URL handler, just like you did to handle 304 codes.
 
    Example 11.11. Defining the redirect handler
    
 
    This class is defined in openanything.py.
     class SmartRedirectHandler(urllib2.HTTPRedirectHandler):     1
@@ -9635,13 +9158,13 @@ class SmartRedirectHandler(urllib2.HTTPRedirectHandler):     1 
 
-Redirect behavior is defined in urllib2 in a class called HTTPRedirectHandler.  You don't want to completely override the behavior, you just want to extend it a little, so you'll subclass HTTPRedirectHandler so you can call the ancestor class to do all the hard work.
+Redirect behavior is defined in urllib2 in a class called HTTPRedirectHandler. You don't want to completely override the behavior, you just want to extend it a little, so you'll subclass HTTPRedirectHandler so you can call the ancestor class to do all the hard work.
 
 
 
 2 
 
-When it encounters a 301 status code from the server, urllib2 will search through its handlers and call the http_error_301 method.   The first thing ours does is just call the http_error_301 method in the ancestor, which handles the grunt work of looking for the Location: header and following the redirect to the new address.
+When it encounters a 301 status code from the server, urllib2 will search through its handlers and call the http_error_301 method.  The first thing ours does is just call the http_error_301 method in the ancestor, which handles the grunt work of looking for the Location: header and following the redirect to the new address.
 
 
 
@@ -9664,7 +9187,7 @@ follow redirects, but now it will also expose the redirect status code.
 >>> import openanything, httplib
 >>> httplib.HTTPConnection.debuglevel = 1
 >>> opener = urllib2.build_opener(
-...     openanything.SmartRedirectHandler())           1
+...    openanything.SmartRedirectHandler())           1
 >>> f = opener.open(request)
 connect: (diveintomark.org, 80)
 send: 'GET /redir/example301.xml HTTP/1.0
@@ -9708,23 +9231,23 @@ header: Content-Type: application/atom+xml
 
 2 
 
-You sent off a request, and you got a 301 status code in response.  At this point, the http_error_301 method gets called.  You call the ancestor method, which follows the redirect and sends a request at the new location (http://diveintomark.org/xml/atom.xml).
+You sent off a request, and you got a 301 status code in response. At this point, the http_error_301 method gets called. You call the ancestor method, which follows the redirect and sends a request at the new location (http://diveintomark.org/xml/atom.xml).
 
 
 
 3 
 
 This is the payoff: now, not only do you have access to the new URL, but you have access to the redirect status code, so you
-            can tell that this was a permanent redirect.  The next time you request this data, you should request it from the new location
-            (http://diveintomark.org/xml/atom.xml, as specified in f.url).  If you had stored the location in a configuration file or a database, you need to update that so you don't keep pounding
-            the server with requests at the old address.  It's time to update your address book.
+            can tell that this was a permanent redirect. The next time you request this data, you should request it from the new location
+            (http://diveintomark.org/xml/atom.xml, as specified in f.url). If you had stored the location in a configuration file or a database, you need to update that so you don't keep pounding
+            the server with requests at the old address. It's time to update your address book.
 
 
 
 
    The same redirect handler can also tell you that you shouldn't update your address book.
 
    Example 11.13. Using the redirect handler to detect temporary redirects
     >>> request = urllib2.Request(
-...     'http://diveintomark.org/redir/example302.xml')   1
+...    'http://diveintomark.org/redir/example302.xml')   1
 >>> f = opener.open(request)
 connect: (diveintomark.org, 80)
 send: '
@@ -9769,28 +9292,28 @@ http://diveintomark.org/xml/atom.xml
 
 2 
 
-The server sends back a 302 status code, indicating a temporary redirect.  The temporary new location of the data is given in the Location: header.
+The server sends back a 302 status code, indicating a temporary redirect. The temporary new location of the data is given in the Location: header.
 
 
 
 3 
 
-urllib2 calls your http_error_302 method, which calls the ancestor method of the same name in urllib2.HTTPRedirectHandler, which follows the redirect to the new location.  Then your http_error_302 method stores the status code (302) so the calling application can get it later.
+urllib2 calls your http_error_302 method, which calls the ancestor method of the same name in urllib2.HTTPRedirectHandler, which follows the redirect to the new location. Then your http_error_302 method stores the status code (302) so the calling application can get it later.
 
 
 
 4 
 
-And here you are, having successfully followed the redirect to http://diveintomark.org/xml/atom.xml.  f.status tells you that this was a temporary redirect, which means that you should continue to request data from the original address
-            (http://diveintomark.org/redir/example302.xml).  Maybe it will redirect next time too, but maybe not.  Maybe it will redirect to a different address.  It's not for you
-            to say.  The server said this redirect was only temporary, so you should respect that.  And now you're exposing enough information
+And here you are, having successfully followed the redirect to http://diveintomark.org/xml/atom.xml. f.status tells you that this was a temporary redirect, which means that you should continue to request data from the original address
+            (http://diveintomark.org/redir/example302.xml). Maybe it will redirect next time too, but maybe not. Maybe it will redirect to a different address. It's not for you
+            to say. The server said this redirect was only temporary, so you should respect that. And now you're exposing enough information
             that the calling application can respect that.
 
 
 
 
    11.8. Handling compressed data
    
-
    The last important HTTP feature you want to support is compression.  Many web services have the ability to send data compressed,
-   which can cut down the amount of data sent over the wire by 60% or more.  This is especially true of XML web services, since
+
    The last important HTTP feature you want to support is compression. Many web services have the ability to send data compressed,
+   which can cut down the amount of data sent over the wire by 60% or more. This is especially true of XML web services, since
    XML data compresses very well.
 
    Servers won't give you compressed data unless you tell them you can handle it.
 
    Example 11.14. Telling the server you would like compressed data
    @@ -9823,7 +9346,7 @@ header: Content-Type: application/atom+xml
 
 1 
 
-This is the key: once you've created your Request object, add an Accept-encoding header to tell the server you can accept gzip-encoded data.  gzip is the name of the compression algorithm you're using.  In theory there could be other compression algorithms, but gzip is the compression algorithm used by 99% of web servers.
+This is the key: once you've created your Request object, add an Accept-encoding header to tell the server you can accept gzip-encoded data. gzip is the name of the compression algorithm you're using. In theory there could be other compression algorithms, but gzip is the compression algorithm used by 99% of web servers.
 
 
 
@@ -9840,7 +9363,7 @@ header: Content-Type: application/atom+xml
 
 4 
 
-The Content-Length header is the length of the compressed data, not the uncompressed data.  As you'll see in a minute, the actual length of
+The Content-Length header is the length of the compressed data, not the uncompressed data. As you'll see in a minute, the actual length of
             the uncompressed data was 15955, so gzip compression cut your bandwidth by over 60%!
 
 
@@ -9870,16 +9393,16 @@ header: Content-Type: application/atom+xml
 
 1 
 
-Continuing from the previous example, f is the file-like object returned from the URL opener.  Using its read() method would ordinarily get you the uncompressed data, but since this data has been gzip-compressed, this is just the first
+Continuing from the previous example, f is the file-like object returned from the URL opener. Using its read() method would ordinarily get you the uncompressed data, but since this data has been gzip-compressed, this is just the first
             step towards getting the data you really want.
 
 
 
 2 
 
-OK, this step is a little bit of messy workaround.  Python has a gzip module, which reads (and actually writes) gzip-compressed files on disk.  But you don't have a file on disk, you have a gzip-compressed
-            buffer in memory, and you don't want to write out a temporary file just so you can uncompress it.  So what you're going to
-            do is create a file-like object out of the in-memory data (compresseddata), using the StringIO module.  You first saw the StringIO module in the previous chapter, but now you've found another use for it.
+OK, this step is a little bit of messy workaround. Python has a gzip module, which reads (and actually writes) gzip-compressed files on disk. But you don't have a file on disk, you have a gzip-compressed
+            buffer in memory, and you don't want to write out a temporary file just so you can uncompress it. So what you're going to
+            do is create a file-like object out of the in-memory data (compresseddata), using the StringIO module. You first saw the StringIO module in the previous chapter, but now you've found another use for it.
 
 
 
@@ -9891,7 +9414,7 @@ header: Content-Type: application/atom+xml
 
 4 
 
-This is the line that does all the actual work: “reading” from GzipFile will decompress the data.  Strange?  Yes, but it makes sense in a twisted kind of way.  gzipper is a file-like object which represents a gzip-compressed file.  That “file” is not a real file on disk, though; gzipper is really just “reading” from the file-like object you created with StringIO to wrap the compressed data, which is only in memory in the variable compresseddata.  And where did that compressed data come from?  You originally downloaded it from a remote HTTP server by “reading” from the file-like object you built with urllib2.build_opener.  And amazingly, this all just works.  Every step in the chain has no idea that the previous step is faking it.
+This is the line that does all the actual work: “reading” from GzipFile will decompress the data. Strange?  Yes, but it makes sense in a twisted kind of way. gzipper is a file-like object which represents a gzip-compressed file. That “file” is not a real file on disk, though; gzipper is really just “reading” from the file-like object you created with StringIO to wrap the compressed data, which is only in memory in the variable compresseddata. And where did that compressed data come from?  You originally downloaded it from a remote HTTP server by “reading” from the file-like object you built with urllib2.build_opener. And amazingly, this all just works. Every step in the chain has no idea that the previous step is faking it.
 
 
 
@@ -9900,7 +9423,7 @@ header: Content-Type: application/atom+xml
 Look ma, real data. (15955 bytes of it, in fact.)
 
 
-
    “But wait!” I hear you cry.  “This could be even easier!”  I know what you're thinking.  You're thinking that opener.open returns a file-like object, so why not cut out the StringIO middleman and just pass f directly to GzipFile?  OK, maybe you weren't thinking that, but don't worry about it, because it doesn't work.
+
    “But wait!” I hear you cry. “This could be even easier!”  I know what you're thinking. You're thinking that opener.open returns a file-like object, so why not cut out the StringIO middleman and just pass f directly to GzipFile?  OK, maybe you weren't thinking that, but don't worry about it, because it doesn't work.
 
    Example 11.16. Decompressing the data directly from the server
     >>> f = opener.open(request)1
 >>> f.headers.get('Content-Encoding')         2
@@ -9924,7 +9447,7 @@ AttributeError: addinfourl instance has no attribute 'tell'
 
 2 
 
-Simply opening the request will get you the headers (though not download any data yet).  As you can see from the returned
+Simply opening the request will get you the headers (though not download any data yet). As you can see from the returned
 Content-Encoding header, this data has been sent gzip-compressed.
 
 
@@ -9932,14 +9455,14 @@ AttributeError: addinfourl instance has no attribute 'tell'
 3 
 
 Since opener.open returns a file-like object, and you know from the headers that when you read it, you're going to get gzip-compressed data,
-            why not simply pass that file-like object directly to GzipFile?  As you “read” from the GzipFile instance, it will “read” compressed data from the remote HTTP server and decompress it on the fly.  It's a good idea, but unfortunately it doesn't
-            work.  Because of the way gzip compression works, GzipFile needs to save its position and move forwards and backwards through the compressed file.  This doesn't work when the “file” is a stream of bytes coming from a remote server; all you can do with it is retrieve bytes one at a time, not move back and
-            forth through the data stream.  So the inelegant hack of using StringIO is the best solution: download the compressed data, create a file-like object out of it with StringIO, and then decompress the data from that.
+            why not simply pass that file-like object directly to GzipFile?  As you “read” from the GzipFile instance, it will “read” compressed data from the remote HTTP server and decompress it on the fly. It's a good idea, but unfortunately it doesn't
+            work. Because of the way gzip compression works, GzipFile needs to save its position and move forwards and backwards through the compressed file. This doesn't work when the “file” is a stream of bytes coming from a remote server; all you can do with it is retrieve bytes one at a time, not move back and
+            forth through the data stream. So the inelegant hack of using StringIO is the best solution: download the compressed data, create a file-like object out of it with StringIO, and then decompress the data from that.
 
 
 
 
    11.9. Putting it all together
    
-
    You've seen all the pieces for building an intelligent HTTP web services client.  Now let's see how they all fit together.
+
    You've seen all the pieces for building an intelligent HTTP web services client. Now let's see how they all fit together.
 
    Example 11.17. The openanything function
    
 
    This function is defined in openanything.py.
     def openAnything(source, etag=None, lastmodified=None, agent=USER_AGENT):
@@ -9960,14 +9483,14 @@ def openAnything(source, etag=None, lastmodified=None, agent=USER_AGENT):
 
 1 
 
-urlparse is a handy utility module for, you guessed it, parsing URLs.  It's primary function, also called urlparse, takes a URL and splits it into a tuple of (scheme, domain, path, params, query string parameters, and fragment identifier).
+urlparse is a handy utility module for, you guessed it, parsing URLs. It's primary function, also called urlparse, takes a URL and splits it into a tuple of (scheme, domain, path, params, query string parameters, and fragment identifier).
              Of these, the only thing you care about is the scheme, to make sure that you're dealing with an HTTP URL (which urllib2 can handle).
 
 
 
 2 
 
-You identify yourself to the HTTP server with the User-Agent passed in by the calling function.  If no User-Agent was specified, you use a default one defined earlier in the openanything.py module.  You never use the default one defined by urllib2.
+You identify yourself to the HTTP server with the User-Agent passed in by the calling function. If no User-Agent was specified, you use a default one defined earlier in the openanything.py module. You never use the default one defined by urllib2.
 
 
 
@@ -10032,7 +9555,7 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 
 2 
 
-Read the actual data returned from the server.  This may be compressed; if so, you'll decompress it later.
+Read the actual data returned from the server. This may be compressed; if so, you'll decompress it later.
 
 
 3 
@@ -10077,9 +9600,9 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 <feed version="0.3"
 <-- rest of data omitted for brevity -->'}
 >>> if params['status'] == 301:3
-...     url = params['url']
+...    url = params['url']
 >>> newparams = openanything.fetch(
-...     url, params['etag'], params['lastmodified'], useragent)    4
+...    url, params['etag'], params['lastmodified'], useragent)    4
 >>> newparams
 {'url': 'http://diveintomark.org/xml/atom.xml', 
 'lastmodified': None, 
@@ -10091,7 +9614,7 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 
 1 
 
-The very first time you fetch a resource, you don't have an ETag hash or Last-Modified date, so you'll leave those out.  (They're optional parameters.)
+The very first time you fetch a resource, you don't have an ETag hash or Last-Modified date, so you'll leave those out. (They're optional parameters.)
 
 
 
@@ -10139,15 +9662,15 @@ def fetch(source, etag=None, last_modified=None, agent=USER_AGENT):
 
 
    
 
    Chapter 12. SOAP Web Services
    
-
    Chapter 11 focused on document-oriented web services over HTTP.  The “input parameter” was the URL, and the “return value” was an actual XML document which it was your responsibility to parse.
-
    This chapter will focus on SOAP web services, which take a more structured approach.  Rather than dealing with HTTP requests and XML documents directly,
-SOAP allows you to simulate calling functions that return native data types.  As you will see, the illusion is almost perfect;
-you can “call” a function through a SOAP library, with the standard Python calling syntax, and the function appears to return Python objects and values.  But under the covers, the SOAP library has actually performed a complex transaction involving multiple XML documents and a remote server.
-
    SOAP is a complex specification, and it is somewhat misleading to say that SOAP is all about calling remote functions.  Some people would pipe up to add that SOAP allows for one-way asynchronous message passing, and document-oriented web services.  And those people would be correct;
-SOAP can be used that way, and in many different ways.  But this chapter will focus on so-called “RPC-style” SOAP -- calling a remote function and getting results back.
+
    Chapter 11 focused on document-oriented web services over HTTP. The “input parameter” was the URL, and the “return value” was an actual XML document which it was your responsibility to parse.
+
    This chapter will focus on SOAP web services, which take a more structured approach. Rather than dealing with HTTP requests and XML documents directly,
+SOAP allows you to simulate calling functions that return native data types. As you will see, the illusion is almost perfect;
+you can “call” a function through a SOAP library, with the standard Python calling syntax, and the function appears to return Python objects and values. But under the covers, the SOAP library has actually performed a complex transaction involving multiple XML documents and a remote server.
+
    SOAP is a complex specification, and it is somewhat misleading to say that SOAP is all about calling remote functions. Some people would pipe up to add that SOAP allows for one-way asynchronous message passing, and document-oriented web services. And those people would be correct;
+SOAP can be used that way, and in many different ways. But this chapter will focus on so-called “RPC-style” SOAP -- calling a remote function and getting results back.
 
    12.1. Diving In
    
-
    You use Google, right?  It's a popular search engine.  Have you ever wished you could programmatically access Google search
-   results?  Now you can.  Here is a program to search Google from Python.
+
    You use Google, right?  It's a popular search engine. Have you ever wished you could programmatically access Google search
+   results?  Now you can. Here is a program to search Google from Python.
 
    Example 12.1. search.py
    from SOAPpy import WSDL
 
 # you'll need to configure these two values;
@@ -10171,7 +9694,7 @@ if __name__ == '__main__':
         print r['title']
         print r['link']
         print r['description']
-        print
    You can import this as a module and use it from a larger program, or you can run the script from the command line.  On the
+        print
    You can import this as a module and use it from a larger program, or you can run the script from the command line. On the
 command line, you give the search query as a command-line argument, and it prints out the URL, title, and description of the
 top five Google search results.
 
    Here is the sample output for a search for the word “python”.
@@ -10225,17 +9748,17 @@ Dive Into <b>Python</b>. This book is still being written. <b>...</b
 
    Go to http://pyxml.sourceforge.net/, click Downloads, and download the latest version for your operating system.
 
 
  • 
-
    If you are using Windows, there are several choices.  Make sure to download the version of PyXML that matches the version of Python you are using.
+
    If you are using Windows, there are several choices. Make sure to download the version of PyXML that matches the version of Python you are using.
 
 
  • 
-
    Double-click the installer.  If you download PyXML 0.8.3 for Windows and Python 2.3, the installer program will be PyXML-0.8.3.win32-py2.3.exe.
+
    Double-click the installer. If you download PyXML 0.8.3 for Windows and Python 2.3, the installer program will be PyXML-0.8.3.win32-py2.3.exe.
 
 
  • 
 
    Step through the installer program.
 
 
  • 
-
    After the installation is complete, close the installer.  There will not be any visible indication of success (no programs
-            installed on the Start Menu or shortcuts installed on the desktop).  PyXML is simply a collection of XML libraries used by other programs.
+
    After the installation is complete, close the installer. There will not be any visible indication of success (no programs
+            installed on the Start Menu or shortcuts installed on the desktop). PyXML is simply a collection of XML libraries used by other programs.
 
 
 
    To verify that you installed PyXML correctly, run your Python IDE and check the version of the XML libraries you have installed, as shown here.
@@ -10245,7 +9768,7 @@ Dive Into <b>Python</b>. This book is still being written. <b>...</b
 '0.8.3'
 
    • This version number should match the version number of the PyXML installer program you downloaded and ran.
 
    12.2.2. Installing fpconst
    
-
    The second library you need is fpconst, a set of constants and functions for working with IEEE754 double-precision special values.  This provides support for the
+
    The second library you need is fpconst, a set of constants and functions for working with IEEE754 double-precision special values. This provides support for the
    special values Not-a-Number (NaN), Positive Infinity (Inf), and Negative Infinity (-Inf), which are part of the SOAP datatype specification.
 
    
 
    Procedure 12.2. 
    
@@ -10255,11 +9778,11 @@ Dive Into <b>Python</b>. This book is still being written. <b>...</b
 
    Download the latest version of fpconst from http://www.analytics.washington.edu/statcomp/projects/rzope/fpconst/.
 
 
  • 
-
    There are two downloads available, one in .tar.gz format, the other in .zip format.  If you are using Windows, download the .zip file; otherwise, download the .tar.gz file.
+
    There are two downloads available, one in .tar.gz format, the other in .zip format. If you are using Windows, download the .zip file; otherwise, download the .tar.gz file.
 
 
  • 
-
    Decompress the downloaded file.  On Windows XP, you can right-click on the file and choose Extract All; on earlier versions
-            of Windows, you will need a third-party program such as WinZip.  On Mac OS X, you can double-click the compressed file to decompress it with Stuffit Expander.
+
    Decompress the downloaded file. On Windows XP, you can right-click on the file and choose Extract All; on earlier versions
+            of Windows, you will need a third-party program such as WinZip. On Mac OS X, you can double-click the compressed file to decompress it with Stuffit Expander.
 
 
  • 
 
    Open a command prompt and navigate to the directory where you decompressed the fpconst files.
@@ -10284,7 +9807,7 @@ Dive Into <b>Python</b>. This book is still being written. <b>...</b
 
    Go to http://pywebsvcs.sourceforge.net/ and select Latest Official Release under the SOAPpy section.
 
 
  • 
-
    There are two downloads available.  If you are using Windows, download the .zip file; otherwise, download the .tar.gz file.
+
    There are two downloads available. If you are using Windows, download the .zip file; otherwise, download the .tar.gz file.
 
 
  • 
 
    Decompress the downloaded file, just as you did with fpconst.
@@ -10303,8 +9826,8 @@ Dive Into <b>Python</b>. This book is still being written. <b>...</b
 '0.11.4'
 
    • This version number should match the version number of the SOAPpy archive you downloaded and installed.
 
    12.3. First Steps with SOAP
    
-
    The heart of SOAP is the ability to call remote functions.  There are a number of public access SOAP servers that provide simple functions for demonstration purposes.
-
    The most popular public access SOAP server is http://www.xmethods.net/.  This example uses a demonstration function that takes a United States zip code and returns the current temperature in that
+
    The heart of SOAP is the ability to call remote functions. There are a number of public access SOAP servers that provide simple functions for demonstration purposes.
+
    The most popular public access SOAP server is http://www.xmethods.net/. This example uses a demonstration function that takes a United States zip code and returns the current temperature in that
 region.
 
    Example 12.6. Getting the Current Temperature
     >>> from SOAPpy import SOAPProxy            1
@@ -10318,29 +9841,29 @@ region.
 
 1 
 
-You access the remote SOAP server through a proxy class, SOAPProxy.  The proxy handles all the internals of SOAP for you, including creating the XML request document out of the function name and argument list, sending the request over
-            HTTP to the remote SOAP server, parsing the XML response document, and creating native Python values to return.  You'll see what these XML documents look like in the next section.
+You access the remote SOAP server through a proxy class, SOAPProxy. The proxy handles all the internals of SOAP for you, including creating the XML request document out of the function name and argument list, sending the request over
+            HTTP to the remote SOAP server, parsing the XML response document, and creating native Python values to return. You'll see what these XML documents look like in the next section.
 
 
 
 2 
 
-Every SOAP service has a URL which handles all the requests.  The same URL is used for all function calls.  This particular service only has a single function, but later in this chapter you'll see
-            examples of the Google API, which has several functions.  The service URL is shared by all functions.Each SOAP service also has a namespace, which is defined by the server and is completely arbitrary.  It's simply part of the configuration
-            required to call SOAP methods.  It allows the server to share a single service URL and route requests between several unrelated services.  It's like dividing Python modules into packages.
+Every SOAP service has a URL which handles all the requests. The same URL is used for all function calls. This particular service only has a single function, but later in this chapter you'll see
+            examples of the Google API, which has several functions. The service URL is shared by all functions.Each SOAP service also has a namespace, which is defined by the server and is completely arbitrary. It's simply part of the configuration
+            required to call SOAP methods. It allows the server to share a single service URL and route requests between several unrelated services. It's like dividing Python modules into packages.
 
 
 
 3 
 
-You're creating the SOAPProxy with the service URL and the service namespace.  This doesn't make any connection to the SOAP server; it simply creates a local Python object.
+You're creating the SOAPProxy with the service URL and the service namespace. This doesn't make any connection to the SOAP server; it simply creates a local Python object.
 
 
 
 4 
 
-Now with everything configured properly, you can actually call remote SOAP methods as if they were local functions.  You pass arguments just like a normal function, and you get a return value just
-            like a normal function.  But under the covers, there's a heck of a lot going on.
+Now with everything configured properly, you can actually call remote SOAP methods as if they were local functions. You pass arguments just like a normal function, and you get a return value just
+            like a normal function. But under the covers, there's a heck of a lot going on.
 
 
 
@@ -10404,13 +9927,13 @@ region.
 
 3 
 
-Third, call the remote SOAP method as usual.  The SOAP library will print out both the outgoing XML request document, and the incoming XML response document.  This is all the hard
-            work that SOAPProxy is doing for you.  Intimidating, isn't it?  Let's break it down.
+Third, call the remote SOAP method as usual. The SOAP library will print out both the outgoing XML request document, and the incoming XML response document. This is all the hard
+            work that SOAPProxy is doing for you. Intimidating, isn't it?  Let's break it down.
 
 
 
-
    Most of the XML request document that gets sent to the server is just boilerplate.  Ignore all the namespace declarations;
-they're going to be the same (or similar) for all SOAP calls.  The heart of the “function call” is this fragment within the <Body> element:
+
    Most of the XML request document that gets sent to the server is just boilerplate. Ignore all the namespace declarations;
+they're going to be the same (or similar) for all SOAP calls. The heart of the “function call” is this fragment within the <Body> element:
 
     <ns1:getTemp               1
   xmlns:ns1="urn:xmethods-Temperature"       2
@@ -10422,7 +9945,7 @@ they're going to be the same (or similar) for all SOAP calls.
 
 1 
 
-The element name is the function name, getTemp.  SOAPProxy uses getattr as a dispatcher.  Instead of calling separate local methods based on the method name, it actually uses the method name to construct the XML
+The element name is the function name, getTemp. SOAPProxy uses getattr as a dispatcher. Instead of calling separate local methods based on the method name, it actually uses the method name to construct the XML
             request document.
 
 
@@ -10430,17 +9953,17 @@ they're going to be the same (or similar) for all SOAP calls.
 2 
 
 The function's XML element is contained in a specific namespace, which is the namespace you specified when you created the
-SOAPProxy object.  Don't worry about the SOAP-ENC:root; that's boilerplate too.
+SOAPProxy object. Don't worry about the SOAP-ENC:root; that's boilerplate too.
 
 
 
 3 
 
-The arguments of the function also got translated into XML.  SOAPProxy introspects each argument to determine its datatype (in this case it's a string).  The argument datatype goes into the xsi:type attribute, followed by the actual string value.
+The arguments of the function also got translated into XML. SOAPProxy introspects each argument to determine its datatype (in this case it's a string). The argument datatype goes into the xsi:type attribute, followed by the actual string value.
 
 
 
-
    The XML return document is equally easy to understand, once you know what to ignore.  Focus on this fragment within the <Body>:
+
    The XML return document is equally easy to understand, once you know what to ignore. Focus on this fragment within the <Body>:
 
     <ns1:getTempResponse           1
   xmlns:ns1="urn:xmethods-Temperature"           2
@@ -10452,36 +9975,36 @@ they're going to be the same (or similar) for all SOAP calls.
 
 1 
 
-The server wraps the function return value within a <getTempResponse> element.  By convention, this wrapper element is the name of the function, plus Response.  But it could really be almost anything; the important thing that SOAPProxy notices is not the element name, but the namespace.
+The server wraps the function return value within a <getTempResponse> element. By convention, this wrapper element is the name of the function, plus Response. But it could really be almost anything; the important thing that SOAPProxy notices is not the element name, but the namespace.
 
 
 
 2 
 
 The server returns the response in the same namespace we used in the request, the same namespace we specified when we first
-            create the SOAPProxy.  Later in this chapter we'll see what happens if you forget to specify the namespace when creating the SOAPProxy.
+            create the SOAPProxy. Later in this chapter we'll see what happens if you forget to specify the namespace when creating the SOAPProxy.
 
 
 
 3 
 
-The return value is specified, along with its datatype (it's a float).  SOAPProxy uses this explicit datatype to create a Python object of the correct native datatype and return it.
+The return value is specified, along with its datatype (it's a float). SOAPProxy uses this explicit datatype to create a Python object of the correct native datatype and return it.
 
 
 
 
    12.5. Introducing WSDL
    
-
    The SOAPProxy class proxies local method calls and transparently turns then into invocations of remote SOAP methods.  As you've seen, this is a lot of work, and SOAPProxy does it quickly and transparently.  What it doesn't do is provide any means of method introspection.
-
    Consider this: the previous two sections showed an example of calling a simple remote SOAP method with one argument and one return value, both of simple data types.  This required knowing, and keeping track of, the
-service URL, the service namespace, the function name, the number of arguments, and the datatype of each argument.  If any of these is
+
    The SOAPProxy class proxies local method calls and transparently turns then into invocations of remote SOAP methods. As you've seen, this is a lot of work, and SOAPProxy does it quickly and transparently. What it doesn't do is provide any means of method introspection.
+
    Consider this: the previous two sections showed an example of calling a simple remote SOAP method with one argument and one return value, both of simple data types. This required knowing, and keeping track of, the
+service URL, the service namespace, the function name, the number of arguments, and the datatype of each argument. If any of these is
 missing or wrong, the whole thing falls apart.
-
    That shouldn't come as a big surprise.  If I wanted to call a local function, I would need to know what package or module
-it was in (the equivalent of service URL and namespace).  I would need to know the correct function name and the correct number of arguments.  Python deftly handles datatyping without explicit types, but I would still need to know how many argument to pass, and how many
+
    That shouldn't come as a big surprise. If I wanted to call a local function, I would need to know what package or module
+it was in (the equivalent of service URL and namespace). I would need to know the correct function name and the correct number of arguments. Python deftly handles datatyping without explicit types, but I would still need to know how many argument to pass, and how many
 return values to expect.
-
    The big difference is introspection.  As you saw in Chapter 4, Python excels at letting you discover things about modules and functions at runtime.  You can list the available functions within
+
    The big difference is introspection. As you saw in Chapter 4, Python excels at letting you discover things about modules and functions at runtime. You can list the available functions within
 a module, and with a little work, drill down to individual function declarations and arguments.
-
    WSDL lets you do that with SOAP web services.  WSDL stands for “Web Services Description Language”.  Although designed to be flexible enough to describe many types of web services, it is most often used to describe SOAP web services.
-
    A WSDL file is just that: a file.  More specifically, it's an XML file.  It usually lives on the same server you use to access the
-SOAP web services it describes, although there's nothing special about it.  Later in this chapter, we'll download the WSDL file for the Google API and use it locally.  That doesn't mean we're calling Google locally; the WSDL file still describes the remote functions sitting on Google's server.
+
    WSDL lets you do that with SOAP web services. WSDL stands for “Web Services Description Language”. Although designed to be flexible enough to describe many types of web services, it is most often used to describe SOAP web services.
+
    A WSDL file is just that: a file. More specifically, it's an XML file. It usually lives on the same server you use to access the
+SOAP web services it describes, although there's nothing special about it. Later in this chapter, we'll download the WSDL file for the Google API and use it locally. That doesn't mean we're calling Google locally; the WSDL file still describes the remote functions sitting on Google's server.
 
    A WSDL file contains a description of everything involved in calling a SOAP web service:
 
    
 
      
@@ -10496,8 +10019,8 @@ a module, and with a little work, drill down to individual function declarations
 
    
 
    In other words, a WSDL file tells you everything you need to know to be able to call a SOAP web service.
 
    12.6. Introspecting SOAP Web Services with WSDL
    
-
    Like many things in the web services arena, WSDL has a long and checkered history, full of political strife and intrigue.  I will skip over this history entirely, since it
-   bores me to tears.  There were other standards that tried to do similar things, but WSDL won, so let's learn how to use it.
+
    Like many things in the web services arena, WSDL has a long and checkered history, full of political strife and intrigue. I will skip over this history entirely, since it
+   bores me to tears. There were other standards that tried to do similar things, but WSDL won, so let's learn how to use it.
 
    The most fundamental thing that WSDL allows you to do is discover the available methods offered by a SOAP server.
 
    Example 12.8. Discovering The Available Methods
     >>> from SOAPpy import WSDL          1
@@ -10510,24 +10033,24 @@ a module, and with a little work, drill down to individual function declarations
 
 1 
 
-SOAPpy includes a WSDL parser.  At the time of this writing, it was labeled as being in the early stages of development, but I had no problem parsing
+SOAPpy includes a WSDL parser. At the time of this writing, it was labeled as being in the early stages of development, but I had no problem parsing
             any of the WSDL files I tried.
 
 
 
 2 
 
-To use a WSDL file, you again use a proxy class, WSDL.Proxy, which takes a single argument: the WSDL file.  Note that in this case you are passing in the URL of a WSDL file stored on the remote server, but the proxy class works just as well with a local copy of the WSDL file.  The act of creating the WSDL proxy will download the WSDL file and parse it, so it there are any errors in the WSDL file (or it can't be fetched due to networking problems), you'll know about it immediately.
+To use a WSDL file, you again use a proxy class, WSDL.Proxy, which takes a single argument: the WSDL file. Note that in this case you are passing in the URL of a WSDL file stored on the remote server, but the proxy class works just as well with a local copy of the WSDL file. The act of creating the WSDL proxy will download the WSDL file and parse it, so it there are any errors in the WSDL file (or it can't be fetched due to networking problems), you'll know about it immediately.
 
 
 
 3 
 
-The WSDL proxy class exposes the available functions as a Python dictionary, server.methods.  So getting the list of available methods is as simple as calling the dictionary method keys().
+The WSDL proxy class exposes the available functions as a Python dictionary, server.methods. So getting the list of available methods is as simple as calling the dictionary method keys().
 
 
 
-
    Okay, so you know that this SOAP server offers a single method: getTemp.  But how do you call it?  The WSDL proxy object can tell you that too.
+
    Okay, so you know that this SOAP server offers a single method: getTemp. But how do you call it?  The WSDL proxy object can tell you that too.
 
    Example 12.9. Discovering A Method's Arguments
     >>> callInfo = server.methods['getTemp']  1
 >>> callInfo.inparams   2
@@ -10541,7 +10064,7 @@ u'zipcode'
 
 1 
 
-The server.methods dictionary is filled with a SOAPpy-specific structure called CallInfo.  A CallInfo object contains information about one specific function, including the function arguments.
+The server.methods dictionary is filled with a SOAPpy-specific structure called CallInfo. A CallInfo object contains information about one specific function, including the function arguments.
 
 
 
@@ -10553,14 +10076,14 @@ u'zipcode'
 
 3 
 
-Each ParameterInfo object contains a name attribute, which is the argument name.  You are not required to know the argument name to call the function through SOAP, but SOAP does support calling functions with named arguments (just like Python), and WSDL.Proxy will correctly handle mapping named arguments to the remote function if you choose to use them.
+Each ParameterInfo object contains a name attribute, which is the argument name. You are not required to know the argument name to call the function through SOAP, but SOAP does support calling functions with named arguments (just like Python), and WSDL.Proxy will correctly handle mapping named arguments to the remote function if you choose to use them.
 
 
 
 4 
 
-Each parameter is also explicitly typed, using datatypes defined in XML Schema.  You saw this in the wire trace in the previous
-            section; the XML Schema namespace was part of the “boilerplate” I told you to ignore.  For our purposes here, you may continue to ignore it.  The zipcode parameter is a string, and if you pass in a Python string to the WSDL.Proxy object, it will map it correctly and send it to the server.
+Each parameter is also explicitly typed, using datatypes defined in XML Schema. You saw this in the wire trace in the previous
+            section; the XML Schema namespace was part of the “boilerplate” I told you to ignore. For our purposes here, you may continue to ignore it. The zipcode parameter is a string, and if you pass in a Python string to the WSDL.Proxy object, it will map it correctly and send it to the server.
 
 
 
@@ -10577,13 +10100,13 @@ u'return'
 
 1 
 
-The adjunct to callInfo.inparams for function arguments is callInfo.outparams for return value.  It is also a list, because functions called through SOAP can return multiple values, just like Python functions.
+The adjunct to callInfo.inparams for function arguments is callInfo.outparams for return value. It is also a list, because functions called through SOAP can return multiple values, just like Python functions.
 
 
 
 2 
 
-Each ParameterInfo object contains name and type.  This function returns a single value, named return, which is a float.
+Each ParameterInfo object contains name and type. This function returns a single value, named return, which is a float.
 
 
 
@@ -10633,38 +10156,38 @@ u'return'
 
 1 
 
-The configuration is simpler than calling the SOAP service directly, since the WSDL file contains the both service URL and namespace you need to call the service.  Creating the WSDL.Proxy object downloads the WSDL file, parses it, and configures a SOAPProxy object that it uses to call the actual SOAP web service.
+The configuration is simpler than calling the SOAP service directly, since the WSDL file contains the both service URL and namespace you need to call the service. Creating the WSDL.Proxy object downloads the WSDL file, parses it, and configures a SOAPProxy object that it uses to call the actual SOAP web service.
 
 
 
 2 
 
-Once the WSDL.Proxy object is created, you can call a function as easily as you did with the SOAPProxy object.  This is not surprising; the WSDL.Proxy is just a wrapper around the SOAPProxy with some introspection methods added, so the syntax for calling functions is the same.
+Once the WSDL.Proxy object is created, you can call a function as easily as you did with the SOAPProxy object. This is not surprising; the WSDL.Proxy is just a wrapper around the SOAPProxy with some introspection methods added, so the syntax for calling functions is the same.
 
 
 
 3 
 
-You can access the WSDL.Proxy's SOAPProxy with server.soapproxy.  This is useful to turning on debugging, so that when you can call functions through the WSDL proxy, its SOAPProxy will dump the outgoing and incoming XML documents that are going over the wire.
+You can access the WSDL.Proxy's SOAPProxy with server.soapproxy. This is useful to turning on debugging, so that when you can call functions through the WSDL proxy, its SOAPProxy will dump the outgoing and incoming XML documents that are going over the wire.
 
 
 
 
    12.7. Searching Google
    
 
    Let's finally turn to the sample code that you saw that the beginning of this chapter, which does something more useful and
    exciting than get the current temperature.
-
    Google provides a SOAP API for programmatically accessing Google search results.  To use it, you will need to sign up for Google Web Services.
+
    Google provides a SOAP API for programmatically accessing Google search results. To use it, you will need to sign up for Google Web Services.
 
    
 
    Procedure 12.4. Signing Up for Google Web Services
    
 
      
 
    1. 
-
      Go to http://www.google.com/apis/ and create a Google account.  This requires only an email address.  After you sign up you will receive your Google API license
-         key by email.  You will need this key to pass as a parameter whenever you call Google's search functions.
+
      Go to http://www.google.com/apis/ and create a Google account. This requires only an email address. After you sign up you will receive your Google API license
+         key by email. You will need this key to pass as a parameter whenever you call Google's search functions.
 
 
    2. 
-
      Also on http://www.google.com/apis/, download the Google Web APIs developer kit.  This includes some sample code in several programming languages (but not Python), and more importantly, it includes the WSDL file.
+
      Also on http://www.google.com/apis/, download the Google Web APIs developer kit. This includes some sample code in several programming languages (but not Python), and more importantly, it includes the WSDL file.
 
 
    3. 
-
      Decompress the developer kit file and find GoogleSearch.wsdl.  Copy this file to some permanent location on your local drive.  You will need it later in this chapter.
+
      Decompress the developer kit file and find GoogleSearch.wsdl. Copy this file to some permanent location on your local drive. You will need it later in this chapter.
 
 
    
 
    Once you have your developer key and your Google WSDL file in a known place, you can start poking around with Google Web Services.
@@ -10675,7 +10198,7 @@ u'return'
 [u'doGoogleSearch', u'doGetCachedPage', u'doSpellingSuggestion']
 >>> callInfo = server.methods['doGoogleSearch']
 >>> for arg in callInfo.inparams:        3
-...     print arg.name.ljust(15), arg.type
+...    print arg.name.ljust(15), arg.type
 key             (u'http://www.w3.org/2001/XMLSchema', u'string')
 q               (u'http://www.w3.org/2001/XMLSchema', u'string')
 start           (u'http://www.w3.org/2001/XMLSchema', u'int')
@@ -10697,16 +10220,16 @@ oe              (u'http://www.w3.org/2001/XMLSchema', u'string')
 
 2 
 
-According to the WSDL file, Google offers three functions: doGoogleSearch, doGetCachedPage, and doSpellingSuggestion.  These do exactly what they sound like: perform a Google search and return the results programmatically, get access to the
+According to the WSDL file, Google offers three functions: doGoogleSearch, doGetCachedPage, and doSpellingSuggestion. These do exactly what they sound like: perform a Google search and return the results programmatically, get access to the
             cached version of a page from the last time Google saw it, and offer spelling suggestions for commonly misspelled search words.
 
 
 
 3 
 
-The doGoogleSearch function takes a number of parameters of various types.  Note that while the WSDL file can tell you what the arguments are called and what datatype they are, it can't tell you what they mean or how to use
-            them.  It could theoretically tell you the acceptable range of values for each parameter, if only specific values were allowed,
-            but Google's WSDL file is not that detailed.  WSDL.Proxy can't work magic; it can only give you the information provided in the WSDL file.
+The doGoogleSearch function takes a number of parameters of various types. Note that while the WSDL file can tell you what the arguments are called and what datatype they are, it can't tell you what they mean or how to use
+            them. It could theoretically tell you the acceptable range of values for each parameter, if only specific values were allowed,
+            but Google's WSDL file is not that detailed. WSDL.Proxy can't work magic; it can only give you the information provided in the WSDL file.
 
 
 
@@ -10715,18 +10238,18 @@ oe              (u'http://www.w3.org/2001/XMLSchema', u'string')
 
      
 
    • key - Your Google API key, which you received when you signed up for Google web services.
 
-
    • q - The search word or phrase you're looking for.  The syntax is exactly the same as Google's web form, so if you know any
+
    • q - The search word or phrase you're looking for. The syntax is exactly the same as Google's web form, so if you know any
       advanced search syntax or tricks, they all work here as well.
 
-
    • start - The index of the result to start on.  Like the interactive web version of Google, this function returns 10 results at a
-      time.  If you wanted to get the second “page” of results, you would set start to 10.
+
    • start - The index of the result to start on. Like the interactive web version of Google, this function returns 10 results at a
+      time. If you wanted to get the second “page” of results, you would set start to 10.
 
-
    • maxResults - The number of results to return.  Currently capped at 10, although you can specify fewer if you are only interested in
+
    • maxResults - The number of results to return. Currently capped at 10, although you can specify fewer if you are only interested in
       a few results and want to save a little bandwidth.
 
 
    • filter - If True, Google will filter out duplicate pages from the results.
 
-
    • restrict - Set this to country plus a country code to get results only from a particular country.  Example: countryUK to search pages in the United Kingdom.  You can also specify linux, mac, or bsd to search a Google-defined set of technical sites, or unclesam to search sites about the United States government.
+
    • restrict - Set this to country plus a country code to get results only from a particular country. Example: countryUK to search pages in the United Kingdom. You can also specify linux, mac, or bsd to search a Google-defined set of technical sites, or unclesam to search sites about the United States government.
 
 
    • safeSearch - If True, Google will filter out porn sites.
 
@@ -10740,7 +10263,7 @@ oe              (u'http://www.w3.org/2001/XMLSchema', u'string')
 >>> server = WSDL.Proxy('/path/to/your/GoogleSearch.wsdl')
 >>> key = 'YOUR_GOOGLE_API_KEY'
 >>> results = server.doGoogleSearch(key, 'mark', 0, 10, False, "",
-...     False, "", "utf-8", "utf-8")             1
+...    False, "", "utf-8", "utf-8")             1
 >>> len(results.resultElements)2
 10
 >>> results.resultElements[0].URL                3
@@ -10752,24 +10275,24 @@ oe              (u'http://www.w3.org/2001/XMLSchema', u'string')
 
 1 
 
-After setting up the WSDL.Proxy object, you can call server.doGoogleSearch with all ten parameters.  Remember to use your own Google API key that you received when you signed up for Google web services.
+After setting up the WSDL.Proxy object, you can call server.doGoogleSearch with all ten parameters. Remember to use your own Google API key that you received when you signed up for Google web services.
 
 
 
 2 
 
-There's a lot of information returned, but let's look at the actual search results first.  They're stored in results.resultElements, and you can access them just like a normal Python list.
+There's a lot of information returned, but let's look at the actual search results first. They're stored in results.resultElements, and you can access them just like a normal Python list.
 
 
 
 3 
 
-Each element in the resultElements is an object that has a URL, title, snippet, and other useful attributes.  At this point you can use normal Python introspection techniques like dir(results.resultElements[0]) to see the available attributes.  Or you can introspect through the WSDL proxy object and look through the function's outparams.  Each technique will give you the same information.
+Each element in the resultElements is an object that has a URL, title, snippet, and other useful attributes. At this point you can use normal Python introspection techniques like dir(results.resultElements[0]) to see the available attributes. Or you can introspect through the WSDL proxy object and look through the function's outparams. Each technique will give you the same information.
 
 
 
-
      The results object contains more than the actual search results.  It also contains information about the search itself, such as how long
-it took and how many results were found (even though only 10 were returned).  The Google web interface shows this information,
+
      The results object contains more than the actual search results. It also contains information about the search itself, such as how long
+it took and how many results were found (even though only 10 were returned). The Google web interface shows this information,
 and you can access it programmatically too.
 
      Example 12.14. Accessing Secondary Information From Google
       >>> results.searchTime   1
@@ -10788,27 +10311,27 @@ and you can access it programmatically too.
 
 1 
 
-This search took 0.224919 seconds.  That does not include the time spent sending and receiving the actual SOAP XML documents.  It's just the time that Google spent processing your request once it received it.
+This search took 0.224919 seconds. That does not include the time spent sending and receiving the actual SOAP XML documents. It's just the time that Google spent processing your request once it received it.
 
 
 
 2 
 
-In total, there were approximately 30 million results.  You can access them 10 at a time by changing the start parameter and calling server.doGoogleSearch again.
+In total, there were approximately 30 million results. You can access them 10 at a time by changing the start parameter and calling server.doGoogleSearch again.
 
 
 
 3 
 
-For some queries, Google also returns a list of related categories in the Google Directory.  You can append these URLs to http://directory.google.com/ to construct the link to the directory category page.
+For some queries, Google also returns a list of related categories in the Google Directory. You can append these URLs to http://directory.google.com/ to construct the link to the directory category page.
 
 
 
 
      12.8. Troubleshooting SOAP Web Services
      
-
      Of course, the world of SOAP web services is not all happiness and light.  Sometimes things go wrong.
-
      As you've seen throughout this chapter, SOAP involves several layers.  There's the HTTP layer, since SOAP is sending XML documents to, and receiving XML documents from, an HTTP server.  So all the debugging techniques you learned
-in Chapter 11, HTTP Web Services come into play here.  You can import httplib and then set httplib.HTTPConnection.debuglevel = 1 to see the underlying HTTP traffic.
-
      Beyond the underlying HTTP layer, there are a number of things that can go wrong.  SOAPpy does an admirable job hiding the SOAP syntax from you, but that also means it can be difficult to determine where the problem is when things don't work.
+
      Of course, the world of SOAP web services is not all happiness and light. Sometimes things go wrong.
+
      As you've seen throughout this chapter, SOAP involves several layers. There's the HTTP layer, since SOAP is sending XML documents to, and receiving XML documents from, an HTTP server. So all the debugging techniques you learned
+in Chapter 11, HTTP Web Services come into play here. You can import httplib and then set httplib.HTTPConnection.debuglevel = 1 to see the underlying HTTP traffic.
+
      Beyond the underlying HTTP layer, there are a number of things that can go wrong. SOAPpy does an admirable job hiding the SOAP syntax from you, but that also means it can be difficult to determine where the problem is when things don't work.
 
      Here are a few examples of common mistakes that I've made in using SOAP web services, and the errors they generated.
 
      Example 12.15. Calling a Method With an Incorrectly Configured Proxy
       >>> from SOAPpy import SOAPProxy
@@ -10832,18 +10355,18 @@ Unable to determine object id from call: is the method element namespaced?>
 1 
 
-Did you spot the mistake?  You're creating a SOAPProxy manually, and you've correctly specified the service URL, but you haven't specified the namespace.  Since multiple services may be routed through the same service URL, the namespace is essential to determine which service you're trying to talk to, and therefore which method you're really
+Did you spot the mistake?  You're creating a SOAPProxy manually, and you've correctly specified the service URL, but you haven't specified the namespace. Since multiple services may be routed through the same service URL, the namespace is essential to determine which service you're trying to talk to, and therefore which method you're really
             calling.
 
 
 
 2 
 
-The server responds by sending a SOAP Fault, which SOAPpy turns into a Python exception of type SOAPpy.Types.faultType.  All errors returned from any SOAP server will always be SOAP Faults, so you can easily catch this exception.  In this case, the human-readable part of the SOAP Fault gives a clue to the problem: the method element is not namespaced, because the original SOAPProxy object was not configured with a service namespace.
+The server responds by sending a SOAP Fault, which SOAPpy turns into a Python exception of type SOAPpy.Types.faultType. All errors returned from any SOAP server will always be SOAP Faults, so you can easily catch this exception. In this case, the human-readable part of the SOAP Fault gives a clue to the problem: the method element is not namespaced, because the original SOAPProxy object was not configured with a service namespace.
 
 
 
-
      Misconfiguring the basic elements of the SOAP service is one of the problems that WSDL aims to solve.  The WSDL file contains the service URL and namespace, so you can't get it wrong.  Of course, there are still other things you can get wrong.
+
      Misconfiguring the basic elements of the SOAP service is one of the problems that WSDL aims to solve. The WSDL file contains the service URL and namespace, so you can't get it wrong. Of course, there are still other things you can get wrong.
 
      Example 12.16. Calling a Method With the Wrong Arguments
       >>> wsdlFile = 'http://www.xmethods.net/sd/2001/TemperatureService.wsdl'
 >>> server = WSDL.Proxy(wsdlFile)
@@ -10865,15 +10388,15 @@ services.temperature.TempService.getTemp(int) -- no signature match>
 
 1 
 
-Did you spot the mistake?  It's a subtle one: you're calling server.getTemp with an integer instead of a string.  As you saw from introspecting the WSDL file, the getTemp() SOAP function takes a single argument, zipcode, which must be a string.  WSDL.Proxy will not coerce datatypes for you; you need to pass the exact datatypes that the server expects.
+Did you spot the mistake?  It's a subtle one: you're calling server.getTemp with an integer instead of a string. As you saw from introspecting the WSDL file, the getTemp() SOAP function takes a single argument, zipcode, which must be a string. WSDL.Proxy will not coerce datatypes for you; you need to pass the exact datatypes that the server expects.
 
 
 
 2 
 
-Again, the server returns a SOAP Fault, and the human-readable part of the error gives a clue as to the problem: you're calling a getTemp function with an integer value, but there is no function defined with that name that takes an integer.  In theory, SOAP allows you to overload functions, so you could have two functions in the same SOAP service with the same name and the same number of arguments, but the arguments were of different datatypes.  This is why
-            it's important to match the datatypes exactly, and why WSDL.Proxy doesn't coerce datatypes for you.  If it did, you could end up calling a completely different function!  Good luck debugging
-            that one.  It's much easier to be picky about datatypes and fail as quickly as possible if you get them wrong.
+Again, the server returns a SOAP Fault, and the human-readable part of the error gives a clue as to the problem: you're calling a getTemp function with an integer value, but there is no function defined with that name that takes an integer. In theory, SOAP allows you to overload functions, so you could have two functions in the same SOAP service with the same name and the same number of arguments, but the arguments were of different datatypes. This is why
+            it's important to match the datatypes exactly, and why WSDL.Proxy doesn't coerce datatypes for you. If it did, you could end up calling a completely different function!  Good luck debugging
+            that one. It's much easier to be picky about datatypes and fail as quickly as possible if you get them wrong.
 
 
 
@@ -10891,7 +10414,7 @@ TypeError: unpack non-sequence
 1 
 
 Did you spot the mistake?  server.getTemp only returns one value, a float, but you've written code that assumes you're getting two values and trying to assign them
-            to two different variables.  Note that this does not fail with a SOAP fault.  As far as the remote server is concerned, nothing went wrong at all.  The error only occurred after the SOAP transaction was complete, WSDL.Proxy returned a float, and your local Python interpreter tried to accomodate your request to split it into two different variables.  Since the function only returned
+            to two different variables. Note that this does not fail with a SOAP fault. As far as the remote server is concerned, nothing went wrong at all. The error only occurred after the SOAP transaction was complete, WSDL.Proxy returned a float, and your local Python interpreter tried to accomodate your request to split it into two different variables. Since the function only returned
             one value, you get a Python exception trying to split it, not a SOAP Fault.
 
 
@@ -10901,7 +10424,7 @@ TypeError: unpack non-sequence
 >>> from SOAPpy import WSDL
 >>> server = WSDL.Proxy(r'/path/to/local/GoogleSearch.wsdl')
 >>> results = server.doGoogleSearch('foo', 'mark', 0, 10, False, "", 1
-...     False, "", "utf-8", "utf-8")
+...    False, "", "utf-8", "utf-8")
 <Fault SOAP-ENV:Server:          2
  Exception from service object: Invalid authorization key: foo:
  <SOAPpy.Types.structType detail at 14164616>:
@@ -10977,14 +10500,14 @@ Caused by: com.google.soap.search.UserKeyInvalidException: Key was of wrong size
 
 1 
 
-Can you spot the mistake?  There's nothing wrong with the calling syntax, or the number of arguments, or the datatypes.  The
+Can you spot the mistake?  There's nothing wrong with the calling syntax, or the number of arguments, or the datatypes. The
             problem is application-specific: the first argument is supposed to be my application key, but foo is not a valid Google key.
 
 
 
 2 
 
-The Google server responds with a SOAP Fault and an incredibly long error message, which includes a complete Java stack trace.  Remember that all SOAP errors are signified by SOAP Faults: errors in configuration, errors in function arguments, and application-specific errors like this.  Buried in there
+The Google server responds with a SOAP Fault and an incredibly long error message, which includes a complete Java stack trace. Remember that all SOAP errors are signified by SOAP Faults: errors in configuration, errors in function arguments, and application-specific errors like this. Buried in there
             somewhere is the crucial piece of information: Invalid authorization key: foo.
 
 
@@ -10996,8 +10519,8 @@ Caused by: com.google.soap.search.UserKeyInvalidException: Key was of wrong size
 
 
    
 
    12.9. Summary
    
-
    SOAP web services are very complicated.  The specification is very ambitious and tries to cover many different use cases for web
-   services.  This chapter has touched on some of the simpler use cases.
+
    SOAP web services are very complicated. The specification is very ambitious and tries to cover many different use cases for web
+   services. This chapter has touched on some of the simpler use cases.
 
    
 
    Before diving into the next chapter, make sure you're comfortable doing all of these things:
 
    
@@ -11014,19 +10537,19 @@ Caused by: com.google.soap.search.UserKeyInvalidException: Key was of wrong size
 
    
 
    Chapter 13. Unit Testing
    
 
    13.1. Introduction to Roman numerals
    
-
    In previous chapters, you “dived in” by immediately looking at code and trying to understand it as quickly as possible.  Now that you have some Python under your belt, you're going to step back and look at the steps that happen before the code gets written.
+
    In previous chapters, you “dived in” by immediately looking at code and trying to understand it as quickly as possible. Now that you have some Python under your belt, you're going to step back and look at the steps that happen before the code gets written.
 
    In the next few chapters, you're going to write, debug, and optimize a set of utility functions to convert to and from Roman
-numerals.  You saw the mechanics of constructing and validating Roman numerals in Section 7.3, “Case Study: Roman Numerals”, but now let's step back and consider what it would take to expand that into a two-way utility.
+numerals. You saw the mechanics of constructing and validating Roman numerals in Section 7.3, “Case Study: Roman Numerals”, but now let's step back and consider what it would take to expand that into a two-way utility.
 
    The rules for Roman numerals lead to a number of interesting observations:
 
    
 
      
 
    1. There is only one correct way to represent a particular number as Roman numerals.
 
    2. The converse is also true: if a string of characters is a valid Roman numeral, it represents only one number (i.e. it can only be read one way).
 
-
    3. There is a limited range of numbers that can be expressed as Roman numerals, specifically 1 through 3999.  (The Romans did have several ways of expressing larger numbers, for instance by having a bar over a numeral to represent
-      that its normal value should be multiplied by 1000, but you're not going to deal with that.  For the purposes of this chapter, let's stipulate that Roman numerals go from 1 to 3999.)
+
    4. There is a limited range of numbers that can be expressed as Roman numerals, specifically 1 through 3999. (The Romans did have several ways of expressing larger numbers, for instance by having a bar over a numeral to represent
+      that its normal value should be multiplied by 1000, but you're not going to deal with that. For the purposes of this chapter, let's stipulate that Roman numerals go from 1 to 3999.)
 
-
    5. There is no way to represent 0 in Roman numerals.  (Amazingly, the ancient Romans had no concept of 0 as a number.  Numbers were for counting things you had; how can you count what you don't have?)
+
    6. There is no way to represent 0 in Roman numerals. (Amazingly, the ancient Romans had no concept of 0 as a number. Numbers were for counting things you had; how can you count what you don't have?)
 
 
    7. There is no way to represent negative numbers in Roman numerals.
 
    8. There is no way to represent fractions or non-integer numbers in Roman numerals.
@@ -11045,7 +10568,7 @@ numerals.  You saw the mechanics of constructing and validating Roman numerals i
 
    9. fromRoman should fail when given an invalid Roman numeral.
 
 
    10. If you take a number, convert it to Roman numerals, then convert that back to a number, you should end up with the number
-      you started with.  So fromRoman(toRoman(n)) == n for all n in 1..3999.
+      you started with. So fromRoman(toRoman(n)) == n for all n in 1..3999.
 
 
    11. toRoman should always return a Roman numeral using uppercase letters.
 
@@ -11061,39 +10584,39 @@ numerals.  You saw the mechanics of constructing and validating Roman numerals i
 
      13.2. Diving in
      
 
      Now that you've completely defined the behavior you expect from your conversion functions, you're going to do something a
    little unexpected: you're going to write a test suite that puts these functions through their paces and makes sure that they
-   behave the way you want them to.  You read that right: you're going to write code that tests code that you haven't written
+   behave the way you want them to. You read that right: you're going to write code that tests code that you haven't written
    yet.
 
      This is called unit testing, since the set of two conversion functions can be written and tested as a unit, separate from
-any larger program they may become part of later.  Python has a framework for unit testing, the appropriately-named unittest module.
+any larger program they may become part of later. Python has a framework for unit testing, the appropriately-named unittest module.
      
-
      
 
      
 Note
 
      
 
      unittest is included with Python 2.1 and later.  Python 2.0 users can download it from pyunit.sourceforge.net.
+unittest is included with Python 2.1 and later. Python 2.0 users can download it from pyunit.sourceforge.net.
 
 
      
 
      
-
      Unit testing is an important part of an overall testing-centric development strategy.  If you write unit tests, it is important
+
      Unit testing is an important part of an overall testing-centric development strategy. If you write unit tests, it is important
 to write them early (preferably before writing the code that they test), and to keep them updated as code and requirements
-change.  Unit testing is not a replacement for higher-level functional or system testing, but it is important in all phases
+change. Unit testing is not a replacement for higher-level functional or system testing, but it is important in all phases
 of development:
 
      
 
        
 
      • Before writing code, it forces you to detail your requirements in a useful fashion.
-
      • While writing code, it keeps you from over-coding.  When all the test cases pass, the function is complete.
+
      • While writing code, it keeps you from over-coding. When all the test cases pass, the function is complete.
 
      • When refactoring code, it assures you that the new version behaves the same way as the old version.
 
      • When maintaining code, it helps you cover your ass when someone comes screaming that your latest change broke their old code.
        (“But sir, all the unit tests passed when I checked it in...”)
 
 
      • When writing code in a team, it increases confidence that the code you're about to commit isn't going to break other peoples'
-      code, because you can run their unittests first. (I've seen this sort of thing in code sprints.  A team breaks up the assignment,
+      code, because you can run their unittests first. (I've seen this sort of thing in code sprints. A team breaks up the assignment,
       everybody takes the specs for their task, writes unit tests for it, then shares their unit tests with the rest of the team.
        That way, nobody goes off too far into developing code that won't play well with others.)
 
 
      
 
      13.3. Introducing romantest.py
      
 
      This is the complete test suite for your Roman numeral conversion functions, which are yet to be written but will eventually
-   be in roman.py.  It is not immediately obvious how it all fits together; none of these classes or methods reference any of the others. 
+   be in roman.py. It is not immediately obvious how it all fits together; none of these classes or methods reference any of the others. 
    There are good reasons for this, as you'll see shortly.
 
      Example 13.1. romantest.py
      
 
      If you have not already done so, you can download this and other examples used in this book.
      @@ -11245,16 +10768,16 @@ if __name__ == "__main__":
 
 
 
      13.4. Testing for success
      
-
      The most fundamental part of unit testing is constructing individual test cases.  A test case answers a single question about
+
      The most fundamental part of unit testing is constructing individual test cases. A test case answers a single question about
    the code it is testing.
 
      A test case should be able to...
 
      
 
        
-
      • ...run completely by itself, without any human input.  Unit testing is about automation.
+
      • ...run completely by itself, without any human input. Unit testing is about automation.
 
      • ...determine by itself whether the function it is testing has passed or failed, without a human interpreting the results.
-
      • ...run in isolation, separate from any other test cases (even if they test the same functions).  Each test case is an island.
+
      • ...run in isolation, separate from any other test cases (even if they test the same functions). Each test case is an island.
 
      
-
      Given that, let's build the first test case.  You have the following requirement:
+
      Given that, let's build the first test case. You have the following requirement:
 
      
 
        
 
      1. toRoman should return the Roman numeral representation for all integers 1 to 3999.
@@ -11328,43 +10851,43 @@ class KnownValues(unittest.TestCase):         1 
 
-To write a test case, first subclass the TestCase class of the unittest module.  This class provides many useful methods which you can use in your test case to test specific conditions.
+To write a test case, first subclass the TestCase class of the unittest module. This class provides many useful methods which you can use in your test case to test specific conditions.
 
 
 
 2 
 
-This is a list of integer/numeral pairs that I verified manually.  It includes the lowest ten numbers, the highest number,
-            every number that translates to a single-character Roman numeral, and a random sampling of other valid numbers.  The point
+This is a list of integer/numeral pairs that I verified manually. It includes the lowest ten numbers, the highest number,
+            every number that translates to a single-character Roman numeral, and a random sampling of other valid numbers. The point
             of a unit test is not to test every possible input, but to test a representative sample.
 
 
 
 3 
 
-Every individual test is its own method, which must take no parameters and return no value.  If the method exits normally
+Every individual test is its own method, which must take no parameters and return no value. If the method exits normally
             without raising an exception, the test is considered passed; if the method raises an exception, the test is considered failed.
 
 
 
 4 
 
-Here you call the actual toRoman function.  (Well, the function hasn't be written yet, but once it is, this is the line that will call it.)  Notice that you
-            have now defined the API for the toRoman function: it must take an integer (the number to convert) and return a string (the Roman numeral representation).  If the
+Here you call the actual toRoman function. (Well, the function hasn't be written yet, but once it is, this is the line that will call it.)  Notice that you
+            have now defined the API for the toRoman function: it must take an integer (the number to convert) and return a string (the Roman numeral representation). If the
 API is different than that, this test is considered failed.
 
 
 
 5 
 
-Also notice that you are not trapping any exceptions when you call toRoman.  This is intentional.  toRoman shouldn't raise an exception when you call it with valid input, and these input values are all valid.  If toRoman raises an exception, this test is considered failed.
+Also notice that you are not trapping any exceptions when you call toRoman. This is intentional. toRoman shouldn't raise an exception when you call it with valid input, and these input values are all valid. If toRoman raises an exception, this test is considered failed.
 
 
 
 6 
 
 Assuming the toRoman function was defined correctly, called correctly, completed successfully, and returned a value, the last step is to check
-            whether it returned the right value.  This is a common question, and the TestCase class provides a method, assertEqual, to check whether two values are equal.  If the result returned from toRoman (result) does not match the known value you were expecting (numeral), assertEqual will raise an exception and the test will fail.  If the two values are equal, assertEqual will do nothing.  If every value returned from toRoman matches the known value you expect, assertEqual never raises an exception, so testToRomanKnownValues eventually exits normally, which means toRoman has passed this test.
+            whether it returned the right value. This is a common question, and the TestCase class provides a method, assertEqual, to check whether two values are equal. If the result returned from toRoman (result) does not match the known value you were expecting (numeral), assertEqual will raise an exception and the test will fail. If the two values are equal, assertEqual will do nothing. If every value returned from toRoman matches the known value you expect, assertEqual never raises an exception, so testToRomanKnownValues eventually exits normally, which means toRoman has passed this test.
 
 
 
@@ -11402,22 +10925,22 @@ class ToRomanBadInput(unittest.TestCase):
 1 
 
 The TestCase class of the unittest provides the assertRaises method, which takes the following arguments: the exception you're expecting, the function you're testing, and the arguments
-            you're passing that function.  (If the function you're testing takes more than one argument, pass them all to assertRaises, in order, and it will pass them right along to the function you're testing.)  Pay close attention to what you're doing here:
-            instead of calling toRoman directly and manually checking that it raises a particular exception (by wrapping it in a try...except block), assertRaises has encapsulated all of that for us.  All you do is give it the exception (roman.OutOfRangeError), the function (toRoman), and toRoman's arguments (4000), and assertRaises takes care of calling toRoman and checking to make sure that it raises roman.OutOfRangeError.  (Also note that you're passing the toRoman function itself as an argument; you're not calling it, and you're not passing the name of it as a string.  Have I mentioned
+            you're passing that function. (If the function you're testing takes more than one argument, pass them all to assertRaises, in order, and it will pass them right along to the function you're testing.)  Pay close attention to what you're doing here:
+            instead of calling toRoman directly and manually checking that it raises a particular exception (by wrapping it in a try...except block), assertRaises has encapsulated all of that for us. All you do is give it the exception (roman.OutOfRangeError), the function (toRoman), and toRoman's arguments (4000), and assertRaises takes care of calling toRoman and checking to make sure that it raises roman.OutOfRangeError. (Also note that you're passing the toRoman function itself as an argument; you're not calling it, and you're not passing the name of it as a string. Have I mentioned
             recently how handy it is that everything in Python is an object, including functions and exceptions?)
 
 
 
 2 
 
-Along with testing numbers that are too large, you need to test numbers that are too small.  Remember, Roman numerals cannot
-            express 0 or negative numbers, so you have a test case for each of those (testZero and testNegative).  In testZero, you are testing that toRoman raises a roman.OutOfRangeError exception when called with 0; if it does not raise a roman.OutOfRangeError (either because it returns an actual value, or because it raises some other exception), this test is considered failed.
+Along with testing numbers that are too large, you need to test numbers that are too small. Remember, Roman numerals cannot
+            express 0 or negative numbers, so you have a test case for each of those (testZero and testNegative). In testZero, you are testing that toRoman raises a roman.OutOfRangeError exception when called with 0; if it does not raise a roman.OutOfRangeError (either because it returns an actual value, or because it raises some other exception), this test is considered failed.
 
 
 
 3 
 
-Requirement #3 specifies that toRoman cannot accept a non-integer number, so here you test to make sure that toRoman raises a roman.NotIntegerError exception when called with 0.5.  If toRoman does not raise a roman.NotIntegerError, this test is considered failed.
+Requirement #3 specifies that toRoman cannot accept a non-integer number, so here you test to make sure that toRoman raises a roman.NotIntegerError exception when called with 0.5. If toRoman does not raise a roman.NotIntegerError, this test is considered failed.
 
 
 
@@ -11429,7 +10952,7 @@ class ToRomanBadInput(unittest.TestCase):
 
      2. fromRoman should fail when given an invalid Roman numeral.
 
 
      
-
      Requirement #4 is handled in the same way as requirement #1, iterating through a sampling of known values and testing each in turn.  Requirement #5 is handled in the same way as requirements
+
      Requirement #4 is handled in the same way as requirement #1, iterating through a sampling of known values and testing each in turn. Requirement #5 is handled in the same way as requirements
 #2 and #3, by testing a series of bad inputs and making sure fromRoman raises the appropriate exception.
 
      Example 13.4. Testing bad input to fromRoman
       class FromRomanBadInput(unittest.TestCase):  
@@ -11452,19 +10975,19 @@ class FromRomanBadInput(unittest.TestCase):
 
 1 
 
-Not much new to say about these; the pattern is exactly the same as the one you used to test bad input to toRoman.  I will briefly note that you have another exception: roman.InvalidRomanNumeralError.  That makes a total of three custom exceptions that will need to be defined in roman.py (along with roman.OutOfRangeError and roman.NotIntegerError).  You'll see how to define these custom exceptions when you actually start writing roman.py, later in this chapter.
+Not much new to say about these; the pattern is exactly the same as the one you used to test bad input to toRoman. I will briefly note that you have another exception: roman.InvalidRomanNumeralError. That makes a total of three custom exceptions that will need to be defined in roman.py (along with roman.OutOfRangeError and roman.NotIntegerError). You'll see how to define these custom exceptions when you actually start writing roman.py, later in this chapter.
 
 
 
 
      13.6. Testing for sanity
      
 
      Often, you will find that a unit of code contains a set of reciprocal functions, usually in the form of conversion functions
-   where one converts A to B and the other converts B to A.  In these cases, it is useful to create a “sanity check” to make sure that you can convert A to B and back to A without losing precision, incurring rounding errors, or triggering
+   where one converts A to B and the other converts B to A. In these cases, it is useful to create a “sanity check” to make sure that you can convert A to B and back to A without losing precision, incurring rounding errors, or triggering
    any other sort of bug.
 
      Consider this requirement:
 
      
 
        
 
      1. If you take a number, convert it to Roman numerals, then convert that back to a number, you should end up with the number
-      you started with.  So fromRoman(toRoman(n)) == n for all n in 1..3999.
+      you started with. So fromRoman(toRoman(n)) == n for all n in 1..3999.
 
 
      
 
      Example 13.5. Testing toRoman against fromRoman
      @@ -11479,7 +11002,7 @@ class SanityCheck(unittest.TestCase):
 
 1 
 
-You've seen the range function before, but here it is called with two arguments, which returns a list of integers starting at the first argument (1) and counting consecutively up to but not including the second argument (4000).  Thus, 1..3999, which is the valid range for converting to Roman numerals.
+You've seen the range function before, but here it is called with two arguments, which returns a list of integers starting at the first argument (1) and counting consecutively up to but not including the second argument (4000). Thus, 1..3999, which is the valid range for converting to Roman numerals.
 
 
 
@@ -11491,7 +11014,7 @@ class SanityCheck(unittest.TestCase):
 
 3 
 
-The actual testing logic here is straightforward: take a number (integer), convert it to a Roman numeral (numeral), then convert it back to a number (result) and make sure you end up with the same number you started with.  If not, assertEqual will raise an exception and the test will immediately be considered failed.  If all the numbers match, assertEqual will always return silently, the entire testSanity method will eventually return silently, and the test will be considered passed.
+The actual testing logic here is straightforward: take a number (integer), convert it to a Roman numeral (numeral), then convert it back to a number (result) and make sure you end up with the same number you started with. If not, assertEqual will raise an exception and the test will immediately be considered failed. If all the numbers match, assertEqual will always return silently, the entire testSanity method will eventually return silently, and the test will be considered passed.
 
 
 
@@ -11503,8 +11026,8 @@ class SanityCheck(unittest.TestCase):
 
    12. fromRoman should only accept uppercase Roman numerals (i.e. it should fail when given lowercase input).
 
 
    
-
    In fact, they are somewhat arbitrary.  You could, for instance, have stipulated that fromRoman accept lowercase and mixed case input.  But they are not completely arbitrary; if toRoman is always returning uppercase output, then fromRoman must at least accept uppercase input, or the “sanity check” (requirement #6) would fail.  The fact that it only accepts uppercase input is arbitrary, but as any systems integrator will tell you, case always matters, so it's worth specifying
-the behavior up front.  And if it's worth specifying, it's worth testing.
+
    In fact, they are somewhat arbitrary. You could, for instance, have stipulated that fromRoman accept lowercase and mixed case input. But they are not completely arbitrary; if toRoman is always returning uppercase output, then fromRoman must at least accept uppercase input, or the “sanity check” (requirement #6) would fail. The fact that it only accepts uppercase input is arbitrary, but as any systems integrator will tell you, case always matters, so it's worth specifying
+the behavior up front. And if it's worth specifying, it's worth testing.
 
    Example 13.6. Testing for case
     class CaseCheck(unittest.TestCase): 
     def testToRomanCase(self):      
@@ -11524,32 +11047,32 @@ class CaseCheck(unittest.TestCase):
 
 1 
 
-The most interesting thing about this test case is all the things it doesn't test.  It doesn't test that the value returned
-            from toRoman is right or even consistent; those questions are answered by separate test cases.  You have a whole test case just to test for uppercase-ness.  You might
-            be tempted to combine this with the sanity check, since both run through the entire range of values and call toRoman.[6]  But that would violate one of the fundamental rules: each test case should answer only a single question.  Imagine that you combined this case check with the sanity check, and
-            then that test case failed.  You would need to do further analysis to figure out which part of the test case failed to determine
-            what the problem was.  If you need to analyze the results of your unit testing just to figure out what they mean, it's a sure
+The most interesting thing about this test case is all the things it doesn't test. It doesn't test that the value returned
+            from toRoman is right or even consistent; those questions are answered by separate test cases. You have a whole test case just to test for uppercase-ness. You might
+            be tempted to combine this with the sanity check, since both run through the entire range of values and call toRoman.[6]  But that would violate one of the fundamental rules: each test case should answer only a single question. Imagine that you combined this case check with the sanity check, and
+            then that test case failed. You would need to do further analysis to figure out which part of the test case failed to determine
+            what the problem was. If you need to analyze the results of your unit testing just to figure out what they mean, it's a sure
             sign that you've mis-designed your test cases.
 
 
 
 2 
 
-There's a similar lesson to be learned here: even though “you know” that toRoman always returns uppercase, you are explicitly converting its return value to uppercase here to test that fromRoman accepts uppercase input.  Why?  Because the fact that toRoman always returns uppercase is an independent requirement.  If you changed that requirement so that, for instance, it always
-            returned lowercase, the testToRomanCase test case would need to change, but this test case would still work.  This was another of the fundamental rules: each test case must be able to work in isolation from any of the others.  Every test case is an island.
+There's a similar lesson to be learned here: even though “you know” that toRoman always returns uppercase, you are explicitly converting its return value to uppercase here to test that fromRoman accepts uppercase input. Why?  Because the fact that toRoman always returns uppercase is an independent requirement. If you changed that requirement so that, for instance, it always
+            returned lowercase, the testToRomanCase test case would need to change, but this test case would still work. This was another of the fundamental rules: each test case must be able to work in isolation from any of the others. Every test case is an island.
 
 
 
 3 
 
-Note that you're not assigning the return value of fromRoman to anything.  This is legal syntax in Python; if a function returns a value but nobody's listening, Python just throws away the return value.  In this case, that's what you want.  This test case doesn't test anything about the return
+Note that you're not assigning the return value of fromRoman to anything. This is legal syntax in Python; if a function returns a value but nobody's listening, Python just throws away the return value. In this case, that's what you want. This test case doesn't test anything about the return
             value; it just tests that fromRoman accepts the uppercase input without raising an exception.
 
 
 
 4 
 
-This is a complicated line, but it's very similar to what you did in the ToRomanBadInput and FromRomanBadInput tests.  You are testing to make sure that calling a particular function (roman.fromRoman) with a particular value (numeral.lower(), the lowercase version of the current Roman numeral in the loop) raises a particular exception (roman.InvalidRomanNumeralError).  If it does (each time through the loop), the test passes; if even one time it does something else (like raises a different
+This is a complicated line, but it's very similar to what you did in the ToRomanBadInput and FromRomanBadInput tests. You are testing to make sure that calling a particular function (roman.fromRoman) with a particular value (numeral.lower(), the lowercase version of the current Roman numeral in the loop) raises a particular exception (roman.InvalidRomanNumeralError). If it does (each time through the loop), the test passes; if even one time it does something else (like raises a different
             exception, or returning a value without raising an exception at all), the test fails.
 
 
@@ -11561,7 +11084,7 @@ class CaseCheck(unittest.TestCase):
 
    
 
    Chapter 14. Test-First Programming
    
 
    14.1. roman.py, stage 1
    
-
    Now that the unit tests are complete, it's time to start writing the code that the test cases are attempting to test.  You're
+
    Now that the unit tests are complete, it's time to start writing the code that the test cases are attempting to test. You're
    going to do this in stages, so you can see all the unit tests fail, then watch them pass one by one as you fill in the gaps
    in roman.py.
 
    Example 14.1. roman1.py
    
@@ -11587,8 +11110,8 @@ def fromRoman(s):
 
 1 
 
-This is how you define your own custom exceptions in Python.  Exceptions are classes, and you create your own by subclassing existing exceptions.  It is strongly recommended (but not
-            required) that you subclass Exception, which is the base class that all built-in exceptions inherit from.  Here I am defining RomanError (inherited from Exception) to act as the base class for all my other custom exceptions to follow.  This is a matter of style; I could just as easily
+This is how you define your own custom exceptions in Python. Exceptions are classes, and you create your own by subclassing existing exceptions. It is strongly recommended (but not
+            required) that you subclass Exception, which is the base class that all built-in exceptions inherit from. Here I am defining RomanError (inherited from Exception) to act as the base class for all my other custom exceptions to follow. This is a matter of style; I could just as easily
             have inherited each individual exception from the Exception class directly.
 
 
@@ -11611,8 +11134,8 @@ def fromRoman(s):
 
 
 
-
    Now for the big moment (drum roll please): you're finally going to run the unit test against this stubby little module.  At
-this point, every test case should fail.  In fact, if any test case passes in stage 1, you should go back to romantest.py and re-evaluate why you coded a test so useless that it passes with do-nothing functions.
+
    Now for the big moment (drum roll please): you're finally going to run the unit test against this stubby little module. At
+this point, every test case should fail. In fact, if any test case passes in stage 1, you should go back to romantest.py and re-evaluate why you coded a test so useless that it passes with do-nothing functions.
 
    Run romantest1.py with the -v command-line option, which will give more verbose output so you can see exactly what's going on as each test case runs. 
 With any luck, your output should look like this:
 
    Example 14.2. Output of romantest1.py against roman1.py
    fromRoman should only accept uppercase input ... ERROR
@@ -11740,13 +11263,13 @@ FAILED (failures=10, errors=2)     1 
 
-Running the script runs unittest.main(), which runs each test case, which is to say each method defined in each class within romantest.py.  For each test case, it prints out the docstring of the method and whether that test passed or failed.  As expected, none of the test cases passed.
+Running the script runs unittest.main(), which runs each test case, which is to say each method defined in each class within romantest.py. For each test case, it prints out the docstring of the method and whether that test passed or failed. As expected, none of the test cases passed.
 
 
 
 2 
 
-For each failed test case, unittest displays the trace information showing exactly what happened.  In this case, the call to assertRaises (also called failUnlessRaises) raised an AssertionError because it was expecting toRoman to raise an OutOfRangeError and it didn't.
+For each failed test case, unittest displays the trace information showing exactly what happened. In this case, the call to assertRaises (also called failUnlessRaises) raised an AssertionError because it was expecting toRoman to raise an OutOfRangeError and it didn't.
 
 
 
@@ -11758,8 +11281,8 @@ FAILED (failures=10, errors=2)     4 
 
-Overall, the unit test failed because at least one test case did not pass.  When a test case doesn't pass, unittest distinguishes between failures and errors.  A failure is a call to an assertXYZ method, like assertEqual or assertRaises, that fails because the asserted condition is not true or the expected exception was not raised.  An error is any other sort
-            of exception raised in the code you're testing or the unit test case itself.  For instance, the testFromRomanCase method (“fromRoman should only accept uppercase input”) was an error, because the call to numeral.upper() raised an AttributeError exception, because toRoman was supposed to return a string but didn't.  But testZero (“toRoman should fail with 0 input”) was a failure, because the call to fromRoman did not raise the InvalidRomanNumeral exception that assertRaises was looking for.
+Overall, the unit test failed because at least one test case did not pass. When a test case doesn't pass, unittest distinguishes between failures and errors. A failure is a call to an assertXYZ method, like assertEqual or assertRaises, that fails because the asserted condition is not true or the expected exception was not raised. An error is any other sort
+            of exception raised in the code you're testing or the unit test case itself. For instance, the testFromRomanCase method (“fromRoman should only accept uppercase input”) was an error, because the call to numeral.upper() raised an AttributeError exception, because toRoman was supposed to return a string but didn't. But testZero (“toRoman should fail with 0 input”) was a failure, because the call to fromRoman did not raise the InvalidRomanNumeral exception that assertRaises was looking for.
 
 
 
@@ -11811,12 +11334,12 @@ def fromRoman(s):
 romanNumeralMap is a tuple of tuples which defines three things:
 
    
 
      
-
    1. The character representations of the most basic Roman numerals.  Note that this is not just the single-character Roman numerals;
+
    2. The character representations of the most basic Roman numerals. Note that this is not just the single-character Roman numerals;
    you're also defining two-character pairs like CM (“one hundred less than one thousand”); this will make the toRoman code simpler later.
 
-
    3. The order of the Roman numerals.  They are listed in descending value order, from M all the way down to I.
+
    4. The order of the Roman numerals. They are listed in descending value order, from M all the way down to I.
 
-
    5. The value of each Roman numeral.  Each inner tuple is a pair of (numeral, value).
+
    6. The value of each Roman numeral. Each inner tuple is a pair of (numeral, value).
 
 
    
 
@@ -11825,7 +11348,7 @@ def fromRoman(s):
 2 
 
 Here's where your rich data structure pays off, because you don't need any special logic to handle the subtraction rule. 
-            To convert to Roman numerals, you simply iterate through romanNumeralMap looking for the largest integer value less than or equal to the input.  Once found, you add the Roman numeral representation
+            To convert to Roman numerals, you simply iterate through romanNumeralMap looking for the largest integer value less than or equal to the input. Once found, you add the Roman numeral representation
             to the end of the output, subtract the corresponding integer value from the input, lather, rinse, repeat.
 
 
@@ -11844,7 +11367,7 @@ subtracting 10 from input, adding X to output
 subtracting 10 from input, adding X to output
 subtracting 4 from input, adding IV to output
 'MCDXXIV'
-
    So toRoman appears to work, at least in this manual spot check.  But will it pass the unit testing?  Well no, not entirely.
+
    So toRoman appears to work, at least in this manual spot check. But will it pass the unit testing?  Well no, not entirely.
 
    Example 14.5. Output of romantest2.py against roman2.py
    
 
    Remember to run romantest2.py with the -v command-line flag to enable verbose mode.
    fromRoman should only accept uppercase input ... FAIL
 toRoman should always return uppercase ... ok1
@@ -11862,25 +11385,25 @@ toRoman should fail with 0 input ... FAIL
    
 
 1 
 
-toRoman does, in fact, always return uppercase, because romanNumeralMap defines the Roman numeral representations as uppercase.  So this test passes already.
+toRoman does, in fact, always return uppercase, because romanNumeralMap defines the Roman numeral representations as uppercase. So this test passes already.
 
 
 
 2 
 
-Here's the big news: this version of the toRoman function passes the known values test.  Remember, it's not comprehensive, but it does put the function through its paces with a variety of good inputs, including
-            inputs that produce every single-character Roman numeral, the largest possible input (3999), and the input that produces the longest possible Roman numeral (3888).  At this point, you can be reasonably confident that the function works for any good input value you could throw at it.
+Here's the big news: this version of the toRoman function passes the known values test. Remember, it's not comprehensive, but it does put the function through its paces with a variety of good inputs, including
+            inputs that produce every single-character Roman numeral, the largest possible input (3999), and the input that produces the longest possible Roman numeral (3888). At this point, you can be reasonably confident that the function works for any good input value you could throw at it.
 
 
 
 3 
 
-However, the function does not “work” for bad values; it fails every single bad input test.  That makes sense, because you didn't include any checks for bad input.  Those test cases look for specific exceptions to
-            be raised (via assertRaises), and you're never raising them.  You'll do that in the next stage.
+However, the function does not “work” for bad values; it fails every single bad input test. That makes sense, because you didn't include any checks for bad input. Those test cases look for specific exceptions to
+            be raised (via assertRaises), and you're never raising them. You'll do that in the next stage.
 
 
 
-
    Here's the rest of the output of the unit test, listing the details of all the failures.  You're down to 10.
    
+
    Here's the rest of the output of the unit test, listing the details of all the failures. You're down to 10.
    
 ======================================================================
 FAIL: fromRoman should only accept uppercase input
 ----------------------------------------------------------------------
@@ -12024,13 +11547,13 @@ def fromRoman(s):
 
 1 
 
-This is a nice Pythonic shortcut: multiple comparisons at once.  This is equivalent to if not ((0 < n) and (n < 4000)), but it's much easier to read.  This is the range check, and it should catch inputs that are too large, negative, or zero.
+This is a nice Pythonic shortcut: multiple comparisons at once. This is equivalent to if not ((0 < n) and (n < 4000)), but it's much easier to read. This is the range check, and it should catch inputs that are too large, negative, or zero.
 
 
 
 2 
 
-You raise exceptions yourself with the raise statement.  You can raise any of the built-in exceptions, or you can raise any of your custom exceptions that you've defined.
+You raise exceptions yourself with the raise statement. You can raise any of the built-in exceptions, or you can raise any of your custom exceptions that you've defined.
              The second parameter, the error message, is optional; if given, it is displayed in the traceback that is printed if the exception
             is never handled.
 
@@ -12038,7 +11561,7 @@ def fromRoman(s):
 
 3 
 
-This is the non-integer check.  Non-integers can not be converted to Roman numerals.
+This is the non-integer check. Non-integers can not be converted to Roman numerals.
 
 
 4 
@@ -12076,13 +11599,13 @@ toRoman should fail with 0 input ... ok
    
 
 1 
 
-toRoman still passes the known values test, which is comforting.  All the tests that passed in stage 2 still pass, so the latest code hasn't broken anything.
+toRoman still passes the known values test, which is comforting. All the tests that passed in stage 2 still pass, so the latest code hasn't broken anything.
 
 
 
 2 
 
-More exciting is the fact that all of the bad input tests now pass.  This test, testNonInteger, passes because of the int(n) <> n check.  When a non-integer is passed to toRoman, the int(n) <> n check notices it and raises the NotIntegerError exception, which is what testNonInteger is looking for.
+More exciting is the fact that all of the bad input tests now pass. This test, testNonInteger, passes because of the int(n) <> n check. When a non-integer is passed to toRoman, the int(n) <> n check notices it and raises the NotIntegerError exception, which is what testNonInteger is looking for.
 
 
 
@@ -12155,7 +11678,7 @@ FAILED (failures=6) 1 
 
-You're down to 6 failures, and all of them involve fromRoman: the known values test, the three separate bad input tests, the case check, and the sanity check.  That means that toRoman has passed all the tests it can pass by itself.  (It's involved in the sanity check, but that also requires that fromRoman be written, which it isn't yet.)  Which means that you must stop coding toRoman now.  No tweaking, no twiddling, no extra checks “just in case”.  Stop.  Now.  Back away from the keyboard.
+You're down to 6 failures, and all of them involve fromRoman: the known values test, the three separate bad input tests, the case check, and the sanity check. That means that toRoman has passed all the tests it can pass by itself. (It's involved in the sanity check, but that also requires that fromRoman be written, which it isn't yet.)  Which means that you must stop coding toRoman now. No tweaking, no twiddling, no extra checks “just in case”. Stop. Now. Back away from the keyboard.
 
 
 
@@ -12164,13 +11687,13 @@ FAILED (failures=6) Note
 
 
-The most important thing that comprehensive unit testing can tell you is when to stop coding.  When all the unit tests for
-      a function pass, stop coding the function.  When all the unit tests for an entire module pass, stop coding the module.
+The most important thing that comprehensive unit testing can tell you is when to stop coding. When all the unit tests for
+      a function pass, stop coding the function. When all the unit tests for an entire module pass, stop coding the module.
 
 
 
 
    14.4. roman.py, stage 4
    
-
    Now that toRoman is done, it's time to start coding fromRoman.  Thanks to the rich data structure that maps individual Roman numerals to integer values, this is no more difficult than
+
    Now that toRoman is done, it's time to start coding fromRoman. Thanks to the rich data structure that maps individual Roman numerals to integer values, this is no more difficult than
    the toRoman function.
 
    Example 14.9. roman4.py
    
 
    This file is available in py/roman/stage4/ in the examples directory.
@@ -12214,7 +11737,7 @@ def fromRoman(s):
 
 1 
 
-The pattern here is the same as toRoman.  You iterate through your Roman numeral data structure (a tuple of tuples), and instead of matching the highest integer
+The pattern here is the same as toRoman. You iterate through your Roman numeral data structure (a tuple of tuples), and instead of matching the highest integer
             values as often as possible, you match the “highest” Roman numeral character strings as often as possible.
 
 
@@ -12250,13 +11773,13 @@ toRoman should fail with 0 input ... ok
    
 
 1 
 
-Two pieces of exciting news here.  The first is that fromRoman works for good input, at least for all the known values you test.
+Two pieces of exciting news here. The first is that fromRoman works for good input, at least for all the known values you test.
 
 
 
 2 
 
-The second is that the sanity check also passed.  Combined with the known values tests, you can be reasonably sure that both toRoman and fromRoman work properly for all possible good values.  (This is not guaranteed; it is theoretically possible that toRoman has a bug that produces the wrong Roman numeral for some particular set of inputs, and that fromRoman has a reciprocal bug that produces the same wrong integer values for exactly that set of Roman numerals that toRoman generated incorrectly.  Depending on your application and your requirements, this possibility may bother you; if so, write
+The second is that the sanity check also passed. Combined with the known values tests, you can be reasonably sure that both toRoman and fromRoman work properly for all possible good values. (This is not guaranteed; it is theoretically possible that toRoman has a bug that produces the wrong Roman numeral for some particular set of inputs, and that fromRoman has a reciprocal bug that produces the same wrong integer values for exactly that set of Roman numerals that toRoman generated incorrectly. Depending on your application and your requirements, this possibility may bother you; if so, write
             more comprehensive test cases until it doesn't bother you.)
 
 
@@ -12303,21 +11826,21 @@ Ran 12 tests in 1.222s
 
 FAILED (failures=4)
    14.5. roman.py, stage 5
    
 
    Now that fromRoman works properly with good input, it's time to fit in the last piece of the puzzle: making it work properly with bad input.
-   That means finding a way to look at a string and determine if it's a valid Roman numeral.  This is inherently more difficult
+   That means finding a way to look at a string and determine if it's a valid Roman numeral. This is inherently more difficult
    than validating numeric input in toRoman, but you have a powerful tool at your disposal: regular expressions.
 
    If you're not familiar with regular expressions and didn't read Chapter 7, Regular Expressions, now would be a good time.
-
    As you saw in Section 7.3, “Case Study: Roman Numerals”, there are several simple rules for constructing a Roman numeral, using the letters M, D, C, L, X, V, and I.  Let's review the rules:
+
    As you saw in Section 7.3, “Case Study: Roman Numerals”, there are several simple rules for constructing a Roman numeral, using the letters M, D, C, L, X, V, and I. Let's review the rules:
 
    
 
      
-
    1. Characters are additive.  I is 1, II is 2, and III is 3.  VI is 6 (literally, “5 and 1”), VII is 7, and VIII is 8.
+
    2. Characters are additive. I is 1, II is 2, and III is 3. VI is 6 (literally, “5 and 1”), VII is 7, and VIII is 8.
 
-
    3. The tens characters (I, X, C, and M) can be repeated up to three times.  At 4, you need to subtract from the next highest fives character.  You can't represent 4 as IIII; instead, it is represented as IV (“1 less than 5”).  40 is written as XL (“10 less than 50”), 41 as XLI, 42 as XLII, 43 as XLIII, and then 44 as XLIV (“10 less than 50, then 1 less than 5”).
+
    4. The tens characters (I, X, C, and M) can be repeated up to three times. At 4, you need to subtract from the next highest fives character. You can't represent 4 as IIII; instead, it is represented as IV (“1 less than 5”). 40 is written as XL (“10 less than 50”), 41 as XLI, 42 as XLII, 43 as XLIII, and then 44 as XLIV (“10 less than 50, then 1 less than 5”).
 
-
    5. Similarly, at 9, you need to subtract from the next highest tens character: 8 is VIII, but 9 is IX (“1 less than 10”), not VIIII (since the I character can not be repeated four times).  90 is XC, 900 is CM.
+
    6. Similarly, at 9, you need to subtract from the next highest tens character: 8 is VIII, but 9 is IX (“1 less than 10”), not VIIII (since the I character can not be repeated four times). 90 is XC, 900 is CM.
 
-
    7. The fives characters can not be repeated.  10 is always represented as X, never as VV.  100 is always C, never LL.
+
    8. The fives characters can not be repeated. 10 is always represented as X, never as VV. 100 is always C, never LL.
 
-
    9. Roman numerals are always written highest to lowest, and read left to right, so order of characters matters very much.  DC is 600; CD is a completely different number (400, “100 less than 500”).  CI is 101; IC is not even a valid Roman numeral (because you can't subtract 1 directly from 100; you would need to write it as XCIX, “10 less than 100, then 1 less than 10”).
+
    10. Roman numerals are always written highest to lowest, and read left to right, so order of characters matters very much. DC is 600; CD is a completely different number (400, “100 less than 500”). CI is 101; IC is not even a valid Roman numeral (because you can't subtract 1 directly from 100; you would need to write it as XCIX, “10 less than 100, then 1 less than 10”).
 
 
    
 
    Example 14.12. roman5.py
    
@@ -12381,19 +11904,19 @@ def fromRoman(s):
 
 1 
 
-This is just a continuation of the pattern you discussed in Section 7.3, “Case Study: Roman Numerals”.  The tens places is either XC (90), XL (40), or an optional L followed by 0 to 3 optional X characters.  The ones place is either IX (9), IV (4), or an optional V followed by 0 to 3 optional I characters.
+This is just a continuation of the pattern you discussed in Section 7.3, “Case Study: Roman Numerals”. The tens places is either XC (90), XL (40), or an optional L followed by 0 to 3 optional X characters. The ones place is either IX (9), IV (4), or an optional V followed by 0 to 3 optional I characters.
 
 
 
 2 
 
-Having encoded all that logic into a regular expression, the code to check for invalid Roman numerals becomes trivial.  If
+Having encoded all that logic into a regular expression, the code to check for invalid Roman numerals becomes trivial. If
 re.search returns an object, then the regular expression matched and the input is valid; otherwise, the input is invalid.
 
 
 
 
    At this point, you are allowed to be skeptical that that big ugly regular expression could possibly catch all the types of
-invalid Roman numerals.  But don't take my word for it, look at the results:
+invalid Roman numerals. But don't take my word for it, look at the results:
 
    Example 14.13. Output of romantest5.py against roman5.py
    
 fromRoman should only accept uppercase input ... ok          1
 toRoman should always return uppercase ... ok
@@ -12416,20 +11939,20 @@ OK     4
 1 
 
-One thing I didn't mention about regular expressions is that, by default, they are case-sensitive.  Since the regular expression
-romanNumeralPattern was expressed in uppercase characters, the re.search check will reject any input that isn't completely uppercase.  So the uppercase input test passes.
+One thing I didn't mention about regular expressions is that, by default, they are case-sensitive. Since the regular expression
+romanNumeralPattern was expressed in uppercase characters, the re.search check will reject any input that isn't completely uppercase. So the uppercase input test passes.
 
 
 
 2 
 
-More importantly, the bad input tests pass.  For instance, the malformed antecedents test checks cases like MCMC.  As you've seen, this does not match the regular expression, so fromRoman raises an InvalidRomanNumeralError exception, which is what the malformed antecedents test case is looking for, so the test passes.
+More importantly, the bad input tests pass. For instance, the malformed antecedents test checks cases like MCMC. As you've seen, this does not match the regular expression, so fromRoman raises an InvalidRomanNumeralError exception, which is what the malformed antecedents test case is looking for, so the test passes.
 
 
 
 3 
 
-In fact, all the bad input tests pass.  This regular expression catches everything you could think of when you made your test
+In fact, all the bad input tests pass. This regular expression catches everything you could think of when you made your test
             cases.
 
 
@@ -12451,7 +11974,7 @@ OK     4
 
    Chapter 15. Refactoring
    
 
    15.1. Handling bugs
    
-
    Despite your best efforts to write comprehensive unit tests, bugs happen.  What do I mean by “bug”?  A bug is a test case you haven't written yet.
+
    Despite your best efforts to write comprehensive unit tests, bugs happen. What do I mean by “bug”?  A bug is a test case you haven't written yet.
 
    Example 15.1. The bug
    >>> import roman5
 >>> roman5.fromRoman("") 1
 0
    
@@ -12460,7 +11983,7 @@ OK     41 
 
 Remember in the previous section when you kept seeing that an empty string would match the regular expression you were using to check for valid Roman numerals?
-             Well, it turns out that this is still true for the final version of the regular expression.  And that's a bug; you want an
+             Well, it turns out that this is still true for the final version of the regular expression. And that's a bug; you want an
             empty string to raise an InvalidRomanNumeralError exception just like any other sequence of characters that don't represent a valid Roman numeral.
 
 
@@ -12479,7 +12002,7 @@ class FromRomanBadInput(unittest.TestCase):
 
 1 
 
-Pretty simple stuff here.  Call fromRoman with an empty string and make sure it raises an InvalidRomanNumeralError exception.  The hard part was finding the bug; now that you know about it, testing for it is the easy part.
+Pretty simple stuff here. Call fromRoman with an empty string and make sure it raises an InvalidRomanNumeralError exception. The hard part was finding the bug; now that you know about it, testing for it is the easy part.
 
 
 
@@ -12563,23 +12086,23 @@ OK 22 
 
-All the other test cases still pass, which means that this bug fix didn't break anything else.  Stop coding.
+All the other test cases still pass, which means that this bug fix didn't break anything else. Stop coding.
 
 
-
    Coding this way does not make fixing bugs any easier.  Simple bugs (like this one) require simple test cases; complex bugs
-will require complex test cases.  In a testing-centric environment, it may seem like it takes longer to fix a bug, since you need to articulate in code exactly what the bug is (to write the test case),
-then fix the bug itself.  Then if the test case doesn't pass right away, you need to figure out whether the fix was wrong,
-or whether the test case itself has a bug in it.  However, in the long run, this back-and-forth between test code and code
-tested pays for itself, because it makes it more likely that bugs are fixed correctly the first time.  Also, since you can
-easily re-run all the test cases along with your new one, you are much less likely to break old code when fixing new code.  Today's unit test
+
    Coding this way does not make fixing bugs any easier. Simple bugs (like this one) require simple test cases; complex bugs
+will require complex test cases. In a testing-centric environment, it may seem like it takes longer to fix a bug, since you need to articulate in code exactly what the bug is (to write the test case),
+then fix the bug itself. Then if the test case doesn't pass right away, you need to figure out whether the fix was wrong,
+or whether the test case itself has a bug in it. However, in the long run, this back-and-forth between test code and code
+tested pays for itself, because it makes it more likely that bugs are fixed correctly the first time. Also, since you can
+easily re-run all the test cases along with your new one, you are much less likely to break old code when fixing new code. Today's unit test
 is tomorrow's regression test.
 
    15.2. Handling changing requirements
    
 
    Despite your best efforts to pin your customers to the ground and extract exact requirements from them on pain of horrible
-   nasty things involving scissors and hot wax, requirements will change.  Most customers don't know what they want until they
-   see it, and even if they do, they aren't that good at articulating what they want precisely enough to be useful.  And even
-   if they do, they'll want more in the next release anyway.  So be prepared to update your test cases as requirements change.
-
    Suppose, for instance, that you wanted to expand the range of the Roman numeral conversion functions.  Remember the rule that said that no character could be repeated more than three times?  Well, the Romans were willing to make an exception
-to that rule by having 4 M characters in a row to represent 4000.  If you make this change, you'll be able to expand the range of convertible numbers from 1..3999 to 1..4999.  But first, you need to make some changes to the test cases.
+   nasty things involving scissors and hot wax, requirements will change. Most customers don't know what they want until they
+   see it, and even if they do, they aren't that good at articulating what they want precisely enough to be useful. And even
+   if they do, they'll want more in the next release anyway. So be prepared to update your test cases as requirements change.
+
    Suppose, for instance, that you wanted to expand the range of the Roman numeral conversion functions. Remember the rule that said that no character could be repeated more than three times?  Well, the Romans were willing to make an exception
+to that rule by having 4 M characters in a row to represent 4000. If you make this change, you'll be able to expand the range of convertible numbers from 1..3999 to 1..4999. But first, you need to make some changes to the test cases.
 
    Example 15.6. Modifying test cases for new requirements (romantest71.py)
    
 
    This file is available in py/roman/stage7/ in the examples directory.
 
    If you have not already done so, you can download this and other examples used in this book.
    @@ -12729,25 +12252,25 @@ if __name__ == "__main__":
 1 
 
 The existing known values don't change (they're all still reasonable values to test), but you need to add a few more in the
-4000 range.  Here I've included 4000 (the shortest), 4500 (the second shortest), 4888 (the longest), and 4999 (the largest).
+4000 range. Here I've included 4000 (the shortest), 4500 (the second shortest), 4888 (the longest), and 4999 (the largest).
 
 
 
 2 
 
-The definition of “large input” has changed.  This test used to call toRoman with 4000 and expect an error; now that 4000-4999 are good values, you need to bump this up to 5000.
+The definition of “large input” has changed. This test used to call toRoman with 4000 and expect an error; now that 4000-4999 are good values, you need to bump this up to 5000.
 
 
 
 3 
 
-The definition of “too many repeated numerals” has also changed.  This test used to call fromRoman with 'MMMM' and expect an error; now that MMMM is considered a valid Roman numeral, you need to bump this up to 'MMMMM'.
+The definition of “too many repeated numerals” has also changed. This test used to call fromRoman with 'MMMM' and expect an error; now that MMMM is considered a valid Roman numeral, you need to bump this up to 'MMMMM'.
 
 
 
 4 
 
-The sanity check and case checks loop through every number in the range, from 1 to 3999.  Since the range has now expanded, these for loops need to be updated as well to go up to 4999.
+The sanity check and case checks loop through every number in the range, from 1 to 3999. Since the range has now expanded, these for loops need to be updated as well to go up to 4999.
 
 
 
@@ -12844,8 +12367,8 @@ OutOfRangeError: number out of range (must be 1..3999)
    Example 15.8. Coding the new requirements (roman72.py)
    
 
    This file is available in py/roman/stage7/ in the examples directory.
    @@ -12909,18 +12432,18 @@ def fromRoman(s):
 
 1 
 
-toRoman only needs one small change, in the range check.  Where you used to check 0 < n < 4000, you now check 0 < n < 5000.  And you change the error message that you raise to reflect the new acceptable range (1..4999 instead of 1..3999).  You don't need to make any changes to the rest of the function; it handles the new cases already.  (It merrily adds 'M' for each thousand that it finds; given 4000, it will spit out 'MMMM'.  The only reason it didn't do this before is that you explicitly stopped it with the range check.)
+toRoman only needs one small change, in the range check. Where you used to check 0 < n < 4000, you now check 0 < n < 5000. And you change the error message that you raise to reflect the new acceptable range (1..4999 instead of 1..3999). You don't need to make any changes to the rest of the function; it handles the new cases already. (It merrily adds 'M' for each thousand that it finds; given 4000, it will spit out 'MMMM'. The only reason it didn't do this before is that you explicitly stopped it with the range check.)
 
 
 
 2 
 
-You don't need to make any changes to fromRoman at all.  The only change is to romanNumeralPattern; if you look closely, you'll notice that you added another optional M in the first section of the regular expression.  This will allow up to 4 M characters instead of 3, meaning you will allow the Roman numeral equivalents of 4999 instead of 3999.  The actual fromRoman function is completely general; it just looks for repeated Roman numeral characters and adds them up, without caring how
-         many times they repeat.  The only reason it didn't handle 'MMMM' before is that you explicitly stopped it with the regular expression pattern matching.
+You don't need to make any changes to fromRoman at all. The only change is to romanNumeralPattern; if you look closely, you'll notice that you added another optional M in the first section of the regular expression. This will allow up to 4 M characters instead of 3, meaning you will allow the Roman numeral equivalents of 4999 instead of 3999. The actual fromRoman function is completely general; it just looks for repeated Roman numeral characters and adds them up, without caring how
+         many times they repeat. The only reason it didn't handle 'MMMM' before is that you explicitly stopped it with the regular expression pattern matching.
 
 
 
-
    You may be skeptical that these two small changes are all that you need.  Hey, don't take my word for it; see for yourself:
+
    You may be skeptical that these two small changes are all that you need. Hey, don't take my word for it; see for yourself:
 
    Example 15.9. Output of romantest72.py against roman72.py
    fromRoman should only accept uppercase input ... ok
 toRoman should always return uppercase ... ok
 fromRoman should fail with blank string ... ok
@@ -12943,16 +12466,16 @@ OK 1
 1 
 
-All the test cases pass.  Stop coding.
+All the test cases pass. Stop coding.
 
 
 
    Comprehensive unit testing means never having to rely on a programmer who says “Trust me.”
 
    15.3. Refactoring
    
 
    The best thing about comprehensive unit testing is not the feeling you get when all your test cases finally pass, or even
-   the feeling you get when someone else blames you for breaking their code and you can actually prove that you didn't.  The best thing about unit testing is that it gives you the freedom to refactor mercilessly.
-
    Refactoring is the process of taking working code and making it work better.  Usually, “better” means “faster”, although it can also mean “using less memory”, or “using less disk space”, or simply “more elegantly”.  Whatever it means to you, to your project, in your environment, refactoring is important to the long-term health of any
+   the feeling you get when someone else blames you for breaking their code and you can actually prove that you didn't. The best thing about unit testing is that it gives you the freedom to refactor mercilessly.
+
    Refactoring is the process of taking working code and making it work better. Usually, “better” means “faster”, although it can also mean “using less memory”, or “using less disk space”, or simply “more elegantly”. Whatever it means to you, to your project, in your environment, refactoring is important to the long-term health of any
 program.
-
    Here, “better” means “faster”.  Specifically, the fromRoman function is slower than it needs to be, because of that big nasty regular expression that you use to validate Roman numerals.
+
    Here, “better” means “faster”. Specifically, the fromRoman function is slower than it needs to be, because of that big nasty regular expression that you use to validate Roman numerals.
 It's probably not worth trying to do away with the regular expression altogether (it would be difficult, and it might not
 end up any faster), but you can speed up the function by precompiling the regular expression.
 
    Example 15.10. Compiling regular expressions
    @@ -12971,14 +12494,14 @@ end up any faster), but you can speed up the function by precompiling the regula
 
 1 
 
-This is the syntax you've seen before: re.search takes a regular expression as a string (pattern) and a string to match against it ('M').  If the pattern matches, the function returns a match object which can be queried to find out exactly what matched and
+This is the syntax you've seen before: re.search takes a regular expression as a string (pattern) and a string to match against it ('M'). If the pattern matches, the function returns a match object which can be queried to find out exactly what matched and
             how.
 
 
 
 2 
 
-This is the new syntax: re.compile takes a regular expression as a string and returns a pattern object.  Note there is no string to match here.  Compiling a
+This is the new syntax: re.compile takes a regular expression as a string and returns a pattern object. Note there is no string to match here. Compiling a
             regular expression has nothing to do with matching it against any specific strings (like 'M'); it only involves the regular expression itself.
 
 
@@ -12991,7 +12514,7 @@ end up any faster), but you can speed up the function by precompiling the regula
 
 4 
 
-Calling the compiled pattern object's search function with the string 'M' accomplishes the same thing as calling re.search with both the regular expression and the string 'M'.  Only much, much faster.  (In fact, the re.search function simply compiles the regular expression and calls the resulting pattern object's search method for you.)
+Calling the compiled pattern object's search function with the string 'M' accomplishes the same thing as calling re.search with both the regular expression and the string 'M'. Only much, much faster. (In fact, the re.search function simply compiles the regular expression and calls the resulting pattern object's search method for you.)
 
 
 
@@ -13032,19 +12555,19 @@ def fromRoman(s):
 
 1 
 
-This looks very similar, but in fact a lot has changed.  romanNumeralPattern is no longer a string; it is a pattern object which was returned from re.compile.
+This looks very similar, but in fact a lot has changed. romanNumeralPattern is no longer a string; it is a pattern object which was returned from re.compile.
 
 
 
 2 
 
-That means that you can call methods on romanNumeralPattern directly.  This will be much, much faster than calling re.search every time.  The regular expression is compiled once and stored in romanNumeralPattern when the module is first imported; then, every time you call fromRoman, you can immediately match the input string against the regular expression, without any intermediate steps occurring under
+That means that you can call methods on romanNumeralPattern directly. This will be much, much faster than calling re.search every time. The regular expression is compiled once and stored in romanNumeralPattern when the module is first imported; then, every time you call fromRoman, you can immediately match the input string against the regular expression, without any intermediate steps occurring under
             the covers.
 
 
 
 
    So how much faster is it to compile regular expressions?  See for yourself:
-
    Example 15.12. Output of romantest81.py against roman81.py
    .............          1
+
    Example 15.12. Output of romantest81.py against roman81.py
    .............         1
 ----------------------------------------------------------------------
 Ran 13 tests in 3.385s 2
 
@@ -13053,13 +12576,13 @@ OK   3
 1 
 
-Just a note in passing here: this time, I ran the unit test without the -v option, so instead of the full docstring for each test, you only get a dot for each test that passes.  (If a test failed, you'd get an F, and if it had an error, you'd get an E.  You'd still get complete tracebacks for each failure and error, so you could track down any problems.)
+Just a note in passing here: this time, I ran the unit test without the -v option, so instead of the full docstring for each test, you only get a dot for each test that passes. (If a test failed, you'd get an F, and if it had an error, you'd get an E. You'd still get complete tracebacks for each failure and error, so you could track down any problems.)
 
 
 
 2 
 
-You ran 13 tests in 3.385 seconds, compared to 3.685 seconds without precompiling the regular expressions.  That's an 8% improvement overall, and remember that most of the time spent during the unit test is spent doing other things.  (Separately,
+You ran 13 tests in 3.385 seconds, compared to 3.685 seconds without precompiling the regular expressions. That's an 8% improvement overall, and remember that most of the time spent during the unit test is spent doing other things. (Separately,
             I time-tested the regular expressions by themselves, apart from the rest of the unit tests, and found that compiling this
             regular expression speeds up the search by an average of 54%.)  Not bad for such a simple fix.
 
@@ -13070,8 +12593,8 @@ OK   3Oh, and in case you were wondering, precompiling the regular expression didn't break anything, and you just proved it.
 
 
-
    There is one other performance optimization that I want to try.  Given the complexity of regular expression syntax, it should
-come as no surprise that there is frequently more than one way to write the same expression.  After some discussion about
+
    There is one other performance optimization that I want to try. Given the complexity of regular expression syntax, it should
+come as no surprise that there is frequently more than one way to write the same expression. After some discussion about
 this module on comp.lang.python, someone suggested that I try using the {m,n} syntax for the optional repeated characters.
 
    Example 15.13. roman82.py
    
 
    This file is available in py/roman/stage8/ in the examples directory.
@@ -13090,11 +12613,11 @@ romanNumeralPattern = \
 
 1 
 
-You have replaced M?M?M?M? with M{0,4}.  Both mean the same thing: “match 0 to 4 M characters”.  Similarly, C?C?C? became C{0,3} (“match 0 to 3 C characters”) and so forth for X and I.
+You have replaced M?M?M?M? with M{0,4}. Both mean the same thing: “match 0 to 4 M characters”. Similarly, C?C?C? became C{0,3} (“match 0 to 3 C characters”) and so forth for X and I.
 
 
 
-
    This form of the regular expression is a little shorter (though not any more readable).  The big question is, is it any faster?
+
    This form of the regular expression is a little shorter (though not any more readable). The big question is, is it any faster?
 
    Example 15.14. Output of romantest82.py against roman82.py
    .............
 ----------------------------------------------------------------------
 Ran 13 tests in 3.315s 1
@@ -13104,8 +12627,8 @@ OK   2
 1 
 
-Overall, the unit tests run 2% faster with this form of regular expression.  That doesn't sound exciting, but remember that
-            the search function is a small part of the overall unit test; most of the time is spent doing other things.  (Separately, I time-tested
+Overall, the unit tests run 2% faster with this form of regular expression. That doesn't sound exciting, but remember that
+            the search function is a small part of the overall unit test; most of the time is spent doing other things. (Separately, I time-tested
             just the regular expressions, and found that the search function is 11% faster with this syntax.)  By precompiling the regular expression and rewriting part of it to use this new syntax, you've
             improved the regular expression performance by over 60%, and improved the overall performance of the entire unit test by over 10%.
 
@@ -13113,18 +12636,18 @@ OK   2
 2 
 
-More important than any performance boost is the fact that the module still works perfectly.  This is the freedom I was talking
+More important than any performance boost is the fact that the module still works perfectly. This is the freedom I was talking
             about earlier: the freedom to tweak, change, or rewrite any piece of it and verify that you haven't messed anything up in
-            the process.  This is not a license to endlessly tweak your code just for the sake of tweaking it; you had a very specific
+            the process. This is not a license to endlessly tweak your code just for the sake of tweaking it; you had a very specific
             objective (“make fromRoman faster”), and you were able to accomplish that objective without any lingering doubts about whether you introduced new bugs in the
             process.
 
 
 
-
    One other tweak I would like to make, and then I promise I'll stop refactoring and put this module to bed.  As you've seen
-repeatedly, regular expressions can get pretty hairy and unreadable pretty quickly.  I wouldn't like to come back to this
-module in six months and try to maintain it.  Sure, the test cases pass, so I know that it works, but if I can't figure out
-how it works, it's still going to be difficult to add new features, fix new bugs, or otherwise maintain it.  As you saw in Section 7.5, “Verbose Regular Expressions”, Python provides a way to document your logic line-by-line.
+
    One other tweak I would like to make, and then I promise I'll stop refactoring and put this module to bed. As you've seen
+repeatedly, regular expressions can get pretty hairy and unreadable pretty quickly. I wouldn't like to come back to this
+module in six months and try to maintain it. Sure, the test cases pass, so I know that it works, but if I can't figure out
+how it works, it's still going to be difficult to add new features, fix new bugs, or otherwise maintain it. As you saw in Section 7.5, “Verbose Regular Expressions”, Python provides a way to document your logic line-by-line.
 
    Example 15.15. roman83.py
    
 
    This file is available in py/roman/stage8/ in the examples directory.
 
    If you have not already done so, you can download this and other examples used in this book.
    @@ -13152,8 +12675,8 @@ romanNumeralPattern = re.compile('''
 1 
 
 The re.compile function can take an optional second argument, which is a set of one or more flags that control various options about the
-            compiled regular expression.  Here you're specifying the re.VERBOSE flag, which tells Python that there are in-line comments within the regular expression itself.  The comments and all the whitespace around them are
-not considered part of the regular expression; the re.compile function simply strips them all out when it compiles the expression.  This new, “verbose” version is identical to the old version, but it is infinitely more readable.
+            compiled regular expression. Here you're specifying the re.VERBOSE flag, which tells Python that there are in-line comments within the regular expression itself. The comments and all the whitespace around them are
+not considered part of the regular expression; the re.compile function simply strips them all out when it compiles the expression. This new, “verbose” version is identical to the old version, but it is infinitely more readable.
 
 
 
@@ -13166,25 +12689,25 @@ OK   2
 1 
 
-This new, “verbose” version runs at exactly the same speed as the old version.  In fact, the compiled pattern objects are the same, since the
+This new, “verbose” version runs at exactly the same speed as the old version. In fact, the compiled pattern objects are the same, since the
 re.compile function strips out all the stuff you added.
 
 
 
 2 
 
-This new, “verbose” version passes all the same tests as the old version.  Nothing has changed, except that the programmer who comes back to
+This new, “verbose” version passes all the same tests as the old version. Nothing has changed, except that the programmer who comes back to
             this module in six months stands a fighting chance of understanding how the function works.
 
 
 
 
    15.4. Postscript
    
-
    A clever reader read the previous section and took it to the next level.  The biggest headache (and performance drain) in the program as it is currently written is
-   the regular expression, which is required because you have no other way of breaking down a Roman numeral.  But there's only
+
    A clever reader read the previous section and took it to the next level. The biggest headache (and performance drain) in the program as it is currently written is
+   the regular expression, which is required because you have no other way of breaking down a Roman numeral. But there's only
    5000 of them; why don't you just build a lookup table once, then simply read that?  This idea gets even better when you realize
-   that you don't need to use regular expressions at all.  As you build the lookup table for converting integers to Roman numerals,
+   that you don't need to use regular expressions at all. As you build the lookup table for converting integers to Roman numerals,
    you can build the reverse lookup table to convert Roman numerals to integers.
-
    And best of all, he already had a complete set of unit tests.  He changed over half the code in the module, but the unit tests
+
    And best of all, he already had a complete set of unit tests. He changed over half the code in the module, but the unit tests
 stayed the same, so he could prove that his code worked just as well as the original.
 
    Example 15.17. roman9.py
    
 
    This file is available in py/roman/stage9/ in the examples directory.
@@ -13264,8 +12787,8 @@ Ran 13 tests in 0.791s
 
 OK
 
-
    Remember, the best performance you ever got in the original version was 13 tests in 3.315 seconds.  Of course, it's not entirely
-a fair comparison, because this version will take longer to import (when it fills the lookup tables).  But since import is
+
    Remember, the best performance you ever got in the original version was 13 tests in 3.315 seconds. Of course, it's not entirely
+a fair comparison, because this version will take longer to import (when it fills the lookup tables). But since import is
 only done once, this is negligible in the long run.
 
    The moral of the story?
 
    
@@ -13276,12 +12799,12 @@ only done once, this is negligible in the long run.
 
 
    15.5. Summary
    
 
    Unit testing is a powerful concept which, if properly implemented, can both reduce maintenance costs and increase flexibility
-   in any long-term project.  It is also important to understand that unit testing is not a panacea, a Magic Problem Solver,
-   or a silver bullet.  Writing good test cases is hard, and keeping them up to date takes discipline (especially when customers
-   are screaming for critical bug fixes).  Unit testing is not a replacement for other forms of testing, including functional
-   testing, integration testing, and user acceptance testing.  But it is feasible, and it does work, and once you've seen it
+   in any long-term project. It is also important to understand that unit testing is not a panacea, a Magic Problem Solver,
+   or a silver bullet. Writing good test cases is hard, and keeping them up to date takes discipline (especially when customers
+   are screaming for critical bug fixes). Unit testing is not a replacement for other forms of testing, including functional
+   testing, integration testing, and user acceptance testing. But it is feasible, and it does work, and once you've seen it
    work, you'll wonder how you ever got along without it.
-
    This chapter covered a lot of ground, and much of it wasn't even Python-specific.  There are unit testing frameworks for many languages, all of which require you to understand the same basic concepts:
+
    This chapter covered a lot of ground, and much of it wasn't even Python-specific. There are unit testing frameworks for many languages, all of which require you to understand the same basic concepts:
 
    
 
    
 
      
@@ -13320,20 +12843,20 @@ only done once, this is negligible in the long run.
 
      
 
      Chapter 16. Functional Programming
      
 
      16.1. Diving in
      
-
      In Chapter 13, Unit Testing, you learned about the philosophy of unit testing.  In Chapter 14, Test-First Programming, you stepped through the implementation of basic unit tests in Python.  In Chapter 15, Refactoring, you saw how unit testing makes large-scale refactoring easier.  This chapter will build on those sample programs, but here
+
      In Chapter 13, Unit Testing, you learned about the philosophy of unit testing. In Chapter 14, Test-First Programming, you stepped through the implementation of basic unit tests in Python. In Chapter 15, Refactoring, you saw how unit testing makes large-scale refactoring easier. This chapter will build on those sample programs, but here
    we will focus more on advanced Python-specific techniques, rather than on unit testing itself.
-
      The following is a complete Python program that acts as a cheap and simple regression testing framework.  It takes unit tests that you've written for individual
-modules, collects them all into one big test suite, and runs them all at once.  I actually use this script as part of the
-build process for this book; I have unit tests for several of the example programs (not just the roman.py module featured in Chapter 13, Unit Testing), and the first thing my automated build script does is run this program to make sure all my examples still work.  If this
-regression test fails, the build immediately stops.  I don't want to release non-working examples any more than you want to
+
      The following is a complete Python program that acts as a cheap and simple regression testing framework. It takes unit tests that you've written for individual
+modules, collects them all into one big test suite, and runs them all at once. I actually use this script as part of the
+build process for this book; I have unit tests for several of the example programs (not just the roman.py module featured in Chapter 13, Unit Testing), and the first thing my automated build script does is run this program to make sure all my examples still work. If this
+regression test fails, the build immediately stops. I don't want to release non-working examples any more than you want to
 download them and sit around scratching your head and yelling at your monitor and wondering why they don't work.
 
      Example 16.1. regression.py
      
 
      If you have not already done so, you can download this and other examples used in this book.
       """Regression testing framework
 
 This module will search for scripts in the same directory named
-XYZtest.py.  Each such script should be a test suite that tests a
-module through PyUnit.  (As of Python 2.1, PyUnit is included in
+XYZtest.py. Each such script should be a test suite that tests a
+module through PyUnit. (As of Python 2.1, PyUnit is included in
 the standard library as "unittest".)  This script will aggregate all
 found test suites into one big test suite and run them all at once.
 """
@@ -13414,7 +12937,7 @@ OK
      
 
      16.2. Finding the path
      
 
      When running Python scripts from the command line, it is sometimes useful to know where the currently running script is located on disk.
 
      This is one of those obscure little tricks that is virtually impossible to figure out on your own, but simple to remember
-once you see it.  The key to it is sys.argv.  As you saw in Chapter 9, XML Processing, this is a list that holds the list of command-line arguments.  However, it also holds the name of the running script, exactly
+once you see it. The key to it is sys.argv. As you saw in Chapter 9, XML Processing, this is a list that holds the list of command-line arguments. However, it also holds the name of the running script, exactly
 as it was called from the command line, and this is enough information to determine its location.
 
      Example 16.3. fullpath.py
      
 
      If you have not already done so, you can download this and other examples used in this book.
      @@ -13428,25 +12951,25 @@ print 'full path =', os.path.abspath(pathname) 
 1 
 
-Regardless of how you run a script, sys.argv[0] will always contain the name of the script, exactly as it appears on the command line.  This may or may not include any path
+Regardless of how you run a script, sys.argv[0] will always contain the name of the script, exactly as it appears on the command line. This may or may not include any path
             information, as you'll see shortly.
 
 
 
 2 
 
-os.path.dirname takes a filename as a string and returns the directory path portion.  If the given filename does not include any path information,
+os.path.dirname takes a filename as a string and returns the directory path portion. If the given filename does not include any path information,
 os.path.dirname returns an empty string.
 
 
 
 3 
 
-os.path.abspath is the key here.  It takes a pathname, which can be partial or even blank, and returns a fully qualified pathname.
+os.path.abspath is the key here. It takes a pathname, which can be partial or even blank, and returns a fully qualified pathname.
 
 
 
-
      os.path.abspath deserves further explanation.  It is very flexible; it can take any kind of pathname.
+
      os.path.abspath deserves further explanation. It is very flexible; it can take any kind of pathname.
 
      Example 16.4. Further explanation of os.path.abspath
       >>> import os
 >>> os.getcwd()      1
@@ -13487,7 +13010,7 @@ print 'full path =', os.path.abspath(pathname) 
 5 
 
-os.path.abspath also normalizes the pathname it returns.  Note that this example worked even though I don't actually have a 'foo' directory.  os.path.abspath never checks your actual disk; this is all just string manipulation.
+os.path.abspath also normalizes the pathname it returns. Note that this example worked even though I don't actually have a 'foo' directory. os.path.abspath never checks your actual disk; this is all just string manipulation.
 
 
 
@@ -13504,7 +13027,7 @@ print 'full path =', os.path.abspath(pathname) Note
 
 
-os.path.abspath not only constructs full path names, it also normalizes them.  That means that if you are in the /usr/ directory, os.path.abspath('bin/../local/bin') will return /usr/local/bin.  It normalizes the path by making it as simple as possible.  If you just want to normalize a pathname like this without
+os.path.abspath not only constructs full path names, it also normalizes them. That means that if you are in the /usr/ directory, os.path.abspath('bin/../local/bin') will return /usr/local/bin. It normalizes the path by making it as simple as possible. If you just want to normalize a pathname like this without
       turning it into a full pathname, use os.path.normpath instead.
 
 
@@ -13527,19 +13050,19 @@ full path = /home/you/diveintopython3/common/py
      1 
 
-In the first case, sys.argv[0] includes the full path of the script.  You can then use the os.path.dirname function to strip off the script name and return the full directory name, and os.path.abspath simply returns what you give it.
+In the first case, sys.argv[0] includes the full path of the script. You can then use the os.path.dirname function to strip off the script name and return the full directory name, and os.path.abspath simply returns what you give it.
 
 
 
 2 
 
-If the script is run by using a partial pathname, sys.argv[0] will still contain exactly what appears on the command line.  os.path.dirname will then give you a partial pathname (relative to the current directory), and os.path.abspath will construct a full pathname from the partial pathname.
+If the script is run by using a partial pathname, sys.argv[0] will still contain exactly what appears on the command line. os.path.dirname will then give you a partial pathname (relative to the current directory), and os.path.abspath will construct a full pathname from the partial pathname.
 
 
 
 3 
 
-If the script is run from the current directory without giving any path, os.path.dirname will simply return an empty string.  Given an empty string, os.path.abspath returns the current directory, which is what you want, since the script was run from the current directory.
+If the script is run from the current directory without giving any path, os.path.dirname will simply return an empty string. Given an empty string, os.path.abspath returns the current directory, which is what you want, since the script was run from the current directory.
 
 
 
@@ -13548,13 +13071,13 @@ full path = /home/you/diveintopython3/common/py
      Note
 
 
-Like the other functions in the os and os.path modules, os.path.abspath is cross-platform.  Your results will look slightly different than my examples if you're running on Windows (which uses backslash
-      as a path separator) or Mac OS (which uses colons), but they'll still work.  That's the whole point of the os module.
+Like the other functions in the os and os.path modules, os.path.abspath is cross-platform. Your results will look slightly different than my examples if you're running on Windows (which uses backslash
+      as a path separator) or Mac OS (which uses colons), but they'll still work. That's the whole point of the os module.
 
 
 
 
      Addendum. One reader was dissatisfied with this solution, and wanted to be able to run all the unit tests in the current directory,
-not the directory where regression.py is located.  He suggests this approach instead:
+not the directory where regression.py is located. He suggests this approach instead:
 
      Example 16.6. Running scripts in the current directory
      import sys, os, re, unittest
 
 def regressionTest():
@@ -13566,7 +13089,7 @@ def regressionTest():
 
 1 
 
-Instead of setting path to the directory where the currently running script is located, you set it to the current working directory instead.  This
+Instead of setting path to the directory where the currently running script is located, you set it to the current working directory instead. This
             will be whatever directory you were in before you ran the script, which is not necessarily the same as the directory the script
             is in. (Read that sentence a few times until you get it.)
 
@@ -13574,7 +13097,7 @@ def regressionTest():
 
 2 
 
-Append this directory to the Python library search path, so that when you dynamically import the unit test modules later, Python can find them.  You didn't need to do this when path was the directory of the currently running script, because Python always looks in that directory.
+Append this directory to the Python library search path, so that when you dynamically import the unit test modules later, Python can find them. You didn't need to do this when path was the directory of the currently running script, because Python always looks in that directory.
 
 
 
@@ -13583,25 +13106,25 @@ def regressionTest():
 The rest of the function is the same.
 
 
-
      This technique will allow you to re-use this regression.py script on multiple projects.  Just put the script in a common directory, then change to the project's directory before running
-   it.  All of that project's unit tests will be found and tested, instead of the unit tests in the common directory where regression.py is located.
+
      This technique will allow you to re-use this regression.py script on multiple projects. Just put the script in a common directory, then change to the project's directory before running
+   it. All of that project's unit tests will be found and tested, instead of the unit tests in the common directory where regression.py is located.
 
      16.3. Filtering lists revisited
      
-
      You're already familiar with using list comprehensions to filter lists.  There is another way to accomplish this same thing, which some people feel is more expressive.
+
      You're already familiar with using list comprehensions to filter lists. There is another way to accomplish this same thing, which some people feel is more expressive.
 
      Python has a built-in filter function which takes two arguments, a function and a list, and returns a list.[7]  The function passed as the first argument to filter must itself take one argument, and the list that filter returns will contain all the elements from the list passed to filter for which the function passed to filter returns true.
 
      Got all that?  It's not as difficult as it sounds.
 
      Example 16.7. Introducing filter
       >>> def odd(n):                 1
-...     return n % 2
-...     
+...    return n % 2
+...    
 >>> li = [1, 2, 3, 5, 9, 10, 256, -3]
 >>> filter(odd, li)             2
 [1, 3, 5, 9, -3]
 >>> [e for e in li if odd(e)]   3
 >>> filteredList = []
 >>> for n in li:                4
-...     if odd(n):
-...         filteredList.append(n)
-...     
+...    if odd(n):
+...        filteredList.append(n)
+...    
 >>> filteredList
 [1, 3, 5, 9, -3]
      
 
@@ -13614,7 +13137,7 @@ def regressionTest():
 
-
@@ -13627,7 +13150,7 @@ def regressionTest():
 
-
@@ -13641,25 +13164,25 @@ def regressionTest():
 
-
-
      
 2 
 filter takes two arguments, a function (odd) and a list (li).  It loops through the list and calls odd with each element.  If odd returns a true value (remember, any non-zero value is true in Python), then the element is included in the returned list, otherwise it is filtered out.  The result is a list of only the odd
+filter takes two arguments, a function (odd) and a list (li). It loops through the list and calls odd with each element. If odd returns a true value (remember, any non-zero value is true in Python), then the element is included in the returned list, otherwise it is filtered out. The result is a list of only the odd
             numbers from the original list, in the same order as they appeared in the original.
 
 
      
 4 
 You could also accomplish the same thing with a for loop.  Depending on your programming background, this may seem more “straightforward”, but functions like filter are much more expressive.  Not only is it easier to write, it's easier to read, too.  Reading the for loop is like standing too close to a painting; you see all the details, but it may take a few seconds to be able to step
+You could also accomplish the same thing with a for loop. Depending on your programming background, this may seem more “straightforward”, but functions like filter are much more expressive. Not only is it easier to write, it's easier to read, too. Reading the for loop is like standing too close to a painting; you see all the details, but it may take a few seconds to be able to step
             back and see the bigger picture: “Oh, you're just filtering the list!”
 
 
      1 
 
 As you saw in Section 16.2, “Finding the path”, path may contain the full or partial pathname of the directory of the currently running script, or it may contain an empty string
-            if the script is being run from the current directory.  Either way, files will end up with the names of the files in the same directory as this script you're running.
+            if the script is being run from the current directory. Either way, files will end up with the names of the files in the same directory as this script you're running.
 
 
      
 
      
 2 
 This is a compiled regular expression.  As you saw in Section 15.3, “Refactoring”, if you're going to use the same regular expression over and over, you should compile it for faster performance.  The compiled
-            object has a search method which takes a single argument, the string to search.  If the regular expression matches the string, the search method returns a Match object containing information about the regular expression match; otherwise it returns None, the Python null value.
+This is a compiled regular expression. As you saw in Section 15.3, “Refactoring”, if you're going to use the same regular expression over and over, you should compile it for faster performance. The compiled
+            object has a search method which takes a single argument, the string to search. If the regular expression matches the string, the search method returns a Match object containing information about the regular expression match; otherwise it returns None, the Python null value.
 
 
      
 
      
 3 
 For each element in the files list, you're going to call the search method of the compiled regular expression object, test.  If the regular expression matches, the method will return a Match object, which Python considers to be true, so the element will be included in the list returned by filter.  If the regular expression does not match, the search method will return None, which Python considers to be false, so the element will not be included.
+For each element in the files list, you're going to call the search method of the compiled regular expression object, test. If the regular expression matches, the method will return a Match object, which Python considers to be true, so the element will be included in the list returned by filter. If the regular expression does not match, the search method will return None, which Python considers to be false, so the element will not be included.
 
 
      
 
      
-
      Historical note. Versions of Python prior to 2.0 did not have list comprehensions, so you couldn't filter using list comprehensions; the filter function was the only game in town.  Even with the introduction of list comprehensions in 2.0, some people still prefer the
-old-style filter (and its companion function, map, which you'll see later in this chapter).  Both techniques work at the moment, so which one you use is a matter of style.
+
      Historical note. Versions of Python prior to 2.0 did not have list comprehensions, so you couldn't filter using list comprehensions; the filter function was the only game in town. Even with the introduction of list comprehensions in 2.0, some people still prefer the
+old-style filter (and its companion function, map, which you'll see later in this chapter). Both techniques work at the moment, so which one you use is a matter of style.
 There is discussion that map and filter might be deprecated in a future version of Python, but no decision has been made.
 
      Example 16.9. Filtering using list comprehensions instead
           files = os.listdir(path)             
@@ -13669,16 +13192,16 @@ There is discussion that map and filter might be depre
 
 1 
 
-This will accomplish exactly the same result as using the filter function.  Which way is more expressive?  That's up to you.
+This will accomplish exactly the same result as using the filter function. Which way is more expressive?  That's up to you.
 
 
 
 
      16.4. Mapping lists revisited
      
-
      You're already familiar with using list comprehensions to map one list into another.  There is another way to accomplish the same thing, using the built-in map function.  It works much the same way as the filter function.
+
      You're already familiar with using list comprehensions to map one list into another. There is another way to accomplish the same thing, using the built-in map function. It works much the same way as the filter function.
 
      Example 16.10. Introducing map
       >>> def double(n):
-...     return n*2
-...     
+...    return n*2
+...    
 >>> li = [1, 2, 3, 5, 9, 10, 256, -3]
 >>> map(double, li)     1
 [2, 4, 6, 10, 18, 20, 512, -6]
@@ -13686,22 +13209,22 @@ There is discussion that map and filter might be depre
 [2, 4, 6, 10, 18, 20, 512, -6]
 >>> newlist = []
 >>> for n in li:        3
-...     newlist.append(double(n))
-...     
+...    newlist.append(double(n))
+...    
 >>> newlist
 [2, 4, 6, 10, 18, 20, 512, -6]
      
 
-
-
@@ -13719,14 +13242,14 @@ There is discussion that map and filter might be depre
 
-
      
 
      
 1 
 map takes a function and a list[8] and returns a new list by calling the function with each element of the list in order.  In this case, the function simply
+map takes a function and a list[8] and returns a new list by calling the function with each element of the list in order. In this case, the function simply
             multiplies each element by 2.
 
 
      
 
      
 2 
 You could accomplish the same thing with a list comprehension.  List comprehensions were first introduced in Python 2.0; map has been around forever.
+You could accomplish the same thing with a list comprehension. List comprehensions were first introduced in Python 2.0; map has been around forever.
 
 
      
 
      
 1 
 As a side note, I'd like to point out that map works just as well with lists of mixed datatypes, as long as the function you're using correctly handles each type.  In this
-            case, the double function simply multiplies the given argument by 2, and Python Does The Right Thing depending on the datatype of the argument.  For integers, this means actually multiplying it by 2; for
+As a side note, I'd like to point out that map works just as well with lists of mixed datatypes, as long as the function you're using correctly handles each type. In this
+            case, the double function simply multiplies the given argument by 2, and Python Does The Right Thing depending on the datatype of the argument. For integers, this means actually multiplying it by 2; for
             strings, it means concatenating the string with itself; for tuples, it means making a new tuple that has all of the elements
             of the original, then all of the elements of the original again.
 
 
      
 
      
-
      All right, enough play time.  Let's look at some real code.
+
      All right, enough play time. Let's look at some real code.
 
      Example 16.12. map in regression.py
           filenameToModuleName = lambda f: os.path.splitext(f)[0] 1
     moduleNames = map(filenameToModuleName, files)          2
      
@@ -13734,13 +13257,13 @@ There is discussion that map and filter might be depre
 
 1 
 
-As you saw in Section 4.7, “Using lambda Functions”, lambda defines an inline function.  And as you saw in Example 6.17, “Splitting Pathnames”, os.path.splitext takes a filename and returns a tuple (name, extension).  So filenameToModuleName is a function which will take a filename and strip off the file extension, and return just the name.
+As you saw in Section 4.7, “Using lambda Functions”, lambda defines an inline function. And as you saw in Example 6.17, “Splitting Pathnames”, os.path.splitext takes a filename and returns a tuple (name, extension). So filenameToModuleName is a function which will take a filename and strip off the file extension, and return just the name.
 
 
 
 2 
 
-Calling map takes each filename listed in files, passes it to the function filenameToModuleName, and returns a list of the return values of each of those function calls.  In other words, you strip the file extension off
+Calling map takes each filename listed in files, passes it to the function filenameToModuleName, and returns a list of the return values of each of those function calls. In other words, you strip the file extension off
             of each filename, and store the list of all those stripped filenames in moduleNames.
 
 
@@ -13748,32 +13271,32 @@ There is discussion that map and filter might be depre
 
      As you'll see in the rest of the chapter, you can extend this type of data-centric thinking all the way to the final goal,
 which is to define and execute a single test suite that contains the tests from all of those individual test suites.
 
      16.5. Data-centric programming
      
-
      By now you're probably scratching your head wondering why this is better than using for loops and straight function calls.  And that's a perfectly valid question.  Mostly, it's a matter of perspective.  Using
+
      By now you're probably scratching your head wondering why this is better than using for loops and straight function calls. And that's a perfectly valid question. Mostly, it's a matter of perspective. Using
 map and filter forces you to center your thinking around your data.
-
      In this case, you started with no data at all; the first thing you did was get the directory path of the current script, and got a list of files in that directory.  That was the bootstrap, and it gave you real data to work
+
      In this case, you started with no data at all; the first thing you did was get the directory path of the current script, and got a list of files in that directory. That was the bootstrap, and it gave you real data to work
 with: a list of filenames.
-
      However, you knew you didn't care about all of those files, only the ones that were actually test suites.  You had too much data, so you needed to filter it.  How did you know which data to keep?  You needed a test to decide, so you defined one and passed it to the filter function.  In this case you used a regular expression to decide, but the concept would be the same regardless of how you
+
      However, you knew you didn't care about all of those files, only the ones that were actually test suites. You had too much data, so you needed to filter it. How did you know which data to keep?  You needed a test to decide, so you defined one and passed it to the filter function. In this case you used a regular expression to decide, but the concept would be the same regardless of how you
 constructed the test.
 
      Now you had the filenames of each of the test suites (and only the test suites, since everything else had been filtered out),
-but you really wanted module names instead.  You had the right amount of data, but it was in the wrong format.  So you defined a function that would transform a single filename into a module name, and you mapped that function onto
-the entire list.  From one filename, you can get a module name; from a list of filenames, you can get a list of module names.
-
      Instead of filter, you could have used a for loop with an if statement.  Instead of map, you could have used a for loop with a function call.  But using for loops like that is busywork.  At best, it simply wastes time; at worst, it introduces obscure bugs.  For instance, you need
-to figure out how to test for the condition “is this file a test suite?” anyway; that's the application-specific logic, and no language can write that for us.  But once you've figured that out,
+but you really wanted module names instead. You had the right amount of data, but it was in the wrong format. So you defined a function that would transform a single filename into a module name, and you mapped that function onto
+the entire list. From one filename, you can get a module name; from a list of filenames, you can get a list of module names.
+
      Instead of filter, you could have used a for loop with an if statement. Instead of map, you could have used a for loop with a function call. But using for loops like that is busywork. At best, it simply wastes time; at worst, it introduces obscure bugs. For instance, you need
+to figure out how to test for the condition “is this file a test suite?” anyway; that's the application-specific logic, and no language can write that for us. But once you've figured that out,
 do you really want go to all the trouble of defining a new empty list and writing a for loop and an if statement and manually calling append to add each element to the new list if it passes the condition and then keeping track of which variable holds the new filtered
 data and which one holds the old unfiltered data?  Why not just define the test condition, then let Python do the rest of that work for us?
-
      Oh sure, you could try to be fancy and delete elements in place without creating a new list.  But you've been burned by that
-before.  Trying to modify a data structure that you're looping through can be tricky.  You delete an element, then loop to
-the next element, and suddenly you've skipped one.  Is Python one of the languages that works that way?  How long would it take you to figure it out?  Would you remember for certain whether
+
      Oh sure, you could try to be fancy and delete elements in place without creating a new list. But you've been burned by that
+before. Trying to modify a data structure that you're looping through can be tricky. You delete an element, then loop to
+the next element, and suddenly you've skipped one. Is Python one of the languages that works that way?  How long would it take you to figure it out?  Would you remember for certain whether
 it was safe the next time you tried?  Programmers spend so much time and make so many mistakes dealing with purely technical
-issues like this, and it's all pointless.  It doesn't advance your program at all; it's just busywork.
-
      I resisted list comprehensions when I first learned Python, and I resisted filter and map even longer.  I insisted on making my life more difficult, sticking to the familiar way of for loops and if statements and step-by-step code-centric programming.  And my Python programs looked a lot like Visual Basic programs, detailing every step of every operation in every function.  And they had all the same types of little problems
-and obscure bugs.  And it was all pointless.
-
      Let it all go.  Busywork code is not important.  Data is important.  And data is not difficult.  It's only data.  If you have
-too much, filter it.  If it's not what you want, map it.  Focus on the data; leave the busywork behind.
+issues like this, and it's all pointless. It doesn't advance your program at all; it's just busywork.
+
      I resisted list comprehensions when I first learned Python, and I resisted filter and map even longer. I insisted on making my life more difficult, sticking to the familiar way of for loops and if statements and step-by-step code-centric programming. And my Python programs looked a lot like Visual Basic programs, detailing every step of every operation in every function. And they had all the same types of little problems
+and obscure bugs. And it was all pointless.
+
      Let it all go. Busywork code is not important. Data is important. And data is not difficult. It's only data. If you have
+too much, filter it. If it's not what you want, map it. Focus on the data; leave the busywork behind.
 
      16.6. Dynamically importing modules
      
-
      OK, enough philosophizing.  Let's talk about dynamically importing modules.
-
      First, let's look at how you normally import modules.  The import module syntax looks in the search path for the named module and imports it by name.  You can even import multiple modules at once
-this way, with a comma-separated list.  You did this on the very first line of this chapter's script.
+
      OK, enough philosophizing. Let's talk about dynamically importing modules.
+
      First, let's look at how you normally import modules. The import module syntax looks in the search path for the named module and imports it by name. You can even import multiple modules at once
+this way, with a comma-separated list. You did this on the very first line of this chapter's script.
 
      Example 16.13. Importing multiple modules at once
       import sys, os, re, unittest 1
 
      
@@ -13806,13 +13329,13 @@ import sys, os, re, unittest 2 
 
-The variable sys is now the sys module, just as if you had said import sys.  The variable os is now the os module, and so forth.
+The variable sys is now the sys module, just as if you had said import sys. The variable os is now the os module, and so forth.
 
 
 
-
      So __import__ imports a module, but takes a string argument to do it.  In this case the module you imported was just a hard-coded string,
-but it could just as easily be a variable, or the result of a function call.  And the variable that you assign the module
-to doesn't need to match the module name, either.  You could import a series of modules and assign them to a list.
+
      So __import__ imports a module, but takes a string argument to do it. In this case the module you imported was just a hard-coded string,
+but it could just as easily be a variable, or the result of a function call. And the variable that you assign the module
+to doesn't need to match the module name, either. You could import a series of modules and assign them to a list.
 
      Example 16.15. Importing a list of modules dynamically
       >>> moduleNames = ['sys', 'os', 're', 'unittest'] 1
 >>> moduleNames
@@ -13833,27 +13356,27 @@ to doesn't need to match the module name, either.  You could import a series of
 
 1 
 
-moduleNames is just a list of strings.  Nothing fancy, except that the strings happen to be names of modules that you could import, if
+moduleNames is just a list of strings. Nothing fancy, except that the strings happen to be names of modules that you could import, if
             you wanted to.
 
 
 
 2 
 
-Surprise, you wanted to import them, and you did, by mapping the __import__ function onto the list.  Remember, this takes each element of the list (moduleNames) and calls the function (__import__) over and over, once with each element of the list, builds a list of the return values, and returns the result.
+Surprise, you wanted to import them, and you did, by mapping the __import__ function onto the list. Remember, this takes each element of the list (moduleNames) and calls the function (__import__) over and over, once with each element of the list, builds a list of the return values, and returns the result.
 
 
 
 3 
 
-So now from a list of strings, you've created a list of actual modules.  (Your paths may be different, depending on your operating
+So now from a list of strings, you've created a list of actual modules. (Your paths may be different, depending on your operating
             system, where you installed Python, the phase of the moon, etc.)
 
 
 
 4 
 
-To drive home the point that these are real modules, let's look at some module attributes.  Remember, modules[0] is the sys module, so modules[0].version is sys.version.  All the other attributes and methods of these modules are also available.  There's nothing magic about the import statement, and there's nothing magic about modules.  Modules are objects.  Everything is an object.
+To drive home the point that these are real modules, let's look at some module attributes. Remember, modules[0] is the sys module, so modules[0].version is sys.version. All the other attributes and methods of these modules are also available. There's nothing magic about the import statement, and there's nothing magic about modules. Modules are objects. Everything is an object.
 
 
 
@@ -13872,7 +13395,7 @@ def regressionTest():
     modules = map(__import__, moduleNames)                 
 load = unittest.defaultTestLoader.loadTestsFromModule  
 return unittest.TestSuite(map(load, modules))          
-
      Let's look at it line by line, interactively.  Assume that the current directory is c:\diveintopython3\py, which contains the examples that come with this book, including this chapter's script.  As you saw in Section 16.2, “Finding the path”, the script directory will end up in the path variable, so let's start hard-code that and go from there.
+
      Let's look at it line by line, interactively. Assume that the current directory is c:\diveintopython3\py, which contains the examples that come with this book, including this chapter's script. As you saw in Section 16.2, “Finding the path”, the script directory will end up in the path variable, so let's start hard-code that and go from there.
 
      Example 16.17. Step 1: Get all the files
       >>> import sys, os, re, unittest
 >>> path = r'c:\diveintopython3\py'
@@ -13890,7 +13413,7 @@ return unittest.TestSuite(map(load, modules))
 
 1 
 
-files is a list of all the files and directories in the script's directory.  (If you've been running some of the examples already,
+files is a list of all the files and directories in the script's directory. (If you've been running some of the examples already,
             you may also see some .pyc files in there as well.)
 
 
@@ -13905,7 +13428,7 @@ return unittest.TestSuite(map(load, modules))
 
 1 
 
-This regular expression will match any string that ends with test.py.  Note that you need to escape the period, since a period in a regular expression usually means “match any single character”, but you actually want to match a literal period instead.
+This regular expression will match any string that ends with test.py. Note that you need to escape the period, since a period in a regular expression usually means “match any single character”, but you actually want to match a literal period instead.
 
 
 
@@ -13936,14 +13459,14 @@ return unittest.TestSuite(map(load, modules))
 
 1 
 
-As you saw in Section 4.7, “Using lambda Functions”, lambda is a quick-and-dirty way of creating an inline, one-line function.  This one takes a filename with an extension and returns
+As you saw in Section 4.7, “Using lambda Functions”, lambda is a quick-and-dirty way of creating an inline, one-line function. This one takes a filename with an extension and returns
             just the filename part, using the standard library function os.path.splitext that you saw in Example 6.17, “Splitting Pathnames”.
 
 
 
 2 
 
-filenameToModuleName is a function.  There's nothing magic about lambda functions as opposed to regular functions that you define with a def statement.  You can call the filenameToModuleName function like any other, and it does just what you wanted it to do: strips the file extension off of its argument.
+filenameToModuleName is a function. There's nothing magic about lambda functions as opposed to regular functions that you define with a def statement. You can call the filenameToModuleName function like any other, and it does just what you wanted it to do: strips the file extension off of its argument.
 
 
 
@@ -14008,21 +13531,21 @@ return unittest.TestSuite(map(load, modules))
 
 1 
 
-These are real module objects.  Not only can you access them like any other module, instantiate classes and call functions,
-            you can also introspect into the module to figure out which classes and functions it has in the first place.  That's what
-            the loadTestsFromModule method does: it introspects into each module and returns a unittest.TestSuite object for each module.  Each TestSuite object actually contains a list of TestSuite objects, one for each TestCase class in your module, and each of those TestSuite objects contains a list of tests, one for each test method in your module.
+These are real module objects. Not only can you access them like any other module, instantiate classes and call functions,
+            you can also introspect into the module to figure out which classes and functions it has in the first place. That's what
+            the loadTestsFromModule method does: it introspects into each module and returns a unittest.TestSuite object for each module. Each TestSuite object actually contains a list of TestSuite objects, one for each TestCase class in your module, and each of those TestSuite objects contains a list of tests, one for each test method in your module.
 
 
 
 2 
 
-Finally, you wrap the list of TestSuite objects into one big test suite.  The unittest module has no problem traversing this tree of nested test suites within test suites; eventually it gets down to an individual
+Finally, you wrap the list of TestSuite objects into one big test suite. The unittest module has no problem traversing this tree of nested test suites within test suites; eventually it gets down to an individual
             test method and executes it, verifies that it passes or fails, and moves on to the next one.
 
 
 
-
      This introspection process is what the unittest module usually does for us.  Remember that magic-looking unittest.main() function that our individual test modules called to kick the whole thing off?  unittest.main() actually creates an instance of unittest.TestProgram, which in turn creates an instance of a unittest.defaultTestLoader and loads it up with the module that called it.  (How does it get a reference to the module that called it if you don't give
-it one?  By using the equally-magic __import__('__main__') command, which dynamically imports the currently-running module.  I could write a book on all the tricks and techniques used
+
      This introspection process is what the unittest module usually does for us. Remember that magic-looking unittest.main() function that our individual test modules called to kick the whole thing off?  unittest.main() actually creates an instance of unittest.TestProgram, which in turn creates an instance of a unittest.defaultTestLoader and loads it up with the module that called it. (How does it get a reference to the module that called it if you don't give
+it one?  By using the equally-magic __import__('__main__') command, which dynamically imports the currently-running module. I could write a book on all the tricks and techniques used
 in the unittest module, but then I'd never finish this one.)
 
      Example 16.22. Step 6: Telling unittest to use your test suite
       if __name__ == "__main__": 
@@ -14032,7 +13555,7 @@ if __name__ == "__main__":
 
 1 
 
-Instead of letting the unittest module do all its magic for us, you've done most of it yourself.  You've created a function (regressionTest) that imports the modules yourself, calls unittest.defaultTestLoader yourself, and wraps it all up in a test suite.  Now all you need to do is tell unittest that, instead of looking for tests and building a test suite in the usual way, it should just call the regressionTest function, which returns a ready-to-use TestSuite.
+Instead of letting the unittest module do all its magic for us, you've done most of it yourself. You've created a function (regressionTest) that imports the modules yourself, calls unittest.defaultTestLoader yourself, and wraps it all up in a test suite. Now all you need to do is tell unittest that, instead of looking for tests and building a test suite in the usual way, it should just call the regressionTest function, which returns a ready-to-use TestSuite.
 
 
 
@@ -14052,40 +13575,40 @@ if __name__ == "__main__":
 
    
 

    
 
    
-
    [7] Technically, the second argument to filter can be any sequence, including lists, tuples, and custom classes that act like lists by defining the __getitem__ special method.  If possible, filter will return the same datatype as you give it, so filtering a list returns a list, but filtering a tuple returns a tuple.
+
    [7] Technically, the second argument to filter can be any sequence, including lists, tuples, and custom classes that act like lists by defining the __getitem__ special method. If possible, filter will return the same datatype as you give it, so filtering a list returns a list, but filtering a tuple returns a tuple.
 
    
-
    [8] Again, I should point out that map can take a list, a tuple, or any object that acts like a sequence.  See previous footnote about filter.
+
    [8] Again, I should point out that map can take a list, a tuple, or any object that acts like a sequence. See previous footnote about filter.
 
    
 
    Chapter 17. Dynamic functions
    
 
    17.1. Diving in
    
-
    I want to talk about plural nouns.  Also, functions that return other functions, advanced regular expressions, and generators.
-   Generators are new in Python 2.3.  But first, let's talk about how to make plural nouns.
-
    If you haven't read Chapter 7, Regular Expressions, now would be a good time.  This chapter assumes you understand the basics of regular expressions, and quickly descends into
+
    I want to talk about plural nouns. Also, functions that return other functions, advanced regular expressions, and generators.
+   Generators are new in Python 2.3. But first, let's talk about how to make plural nouns.
+
    If you haven't read Chapter 7, Regular Expressions, now would be a good time. This chapter assumes you understand the basics of regular expressions, and quickly descends into
 more advanced uses.
 
    English is a schizophrenic language that borrows from a lot of other languages, and the rules for making singular nouns into
-plural nouns are varied and complex.  There are rules, and then there are exceptions to those rules, and then there are exceptions
+plural nouns are varied and complex. There are rules, and then there are exceptions to those rules, and then there are exceptions
 to the exceptions.
 
    If you grew up in an English-speaking country or learned English in a formal school setting, you're probably familiar with
 the basic rules:
 
    
 
      
-
    1. If a word ends in S, X, or Z, add ES.  “Bass” becomes “basses”, “fax” becomes “faxes”, and “waltz” becomes “waltzes”.
+
    2. If a word ends in S, X, or Z, add ES. “Bass” becomes “basses”, “fax” becomes “faxes”, and “waltz” becomes “waltzes”.
 
-
    3. If a word ends in a noisy H, add ES; if it ends in a silent H, just add S.  What's a noisy H?  One that gets combined with
-      other letters to make a sound that you can hear.  So “coach” becomes “coaches” and “rash” becomes “rashes”, because you can hear the CH and SH sounds when you say them.  But “cheetah” becomes “cheetahs”, because the H is silent.
+
    4. If a word ends in a noisy H, add ES; if it ends in a silent H, just add S. What's a noisy H?  One that gets combined with
+      other letters to make a sound that you can hear. So “coach” becomes “coaches” and “rash” becomes “rashes”, because you can hear the CH and SH sounds when you say them. But “cheetah” becomes “cheetahs”, because the H is silent.
 
 
    5. If a word ends in Y that sounds like I, change the Y to IES; if the Y is combined with a vowel to sound like something else,
-      just add S.  So “vacancy” becomes “vacancies”, but “day” becomes “days”.
+      just add S. So “vacancy” becomes “vacancies”, but “day” becomes “days”.
 
 
    6. If all else fails, just add S and hope for the best.
 
    
-
    (I know, there are a lot of exceptions.  “Man” becomes “men” and “woman” becomes “women”, but “human” becomes “humans”.  “Mouse” becomes “mice” and “louse” becomes “lice”, but “house” becomes “houses”.  “Knife” becomes “knives” and “wife” becomes “wives”, but “lowlife” becomes “lowlifes”.  And don't even get me started on words that are their own plural, like “sheep”, “deer”, and “haiku”.)
+
    (I know, there are a lot of exceptions. “Man” becomes “men” and “woman” becomes “women”, but “human” becomes “humans”. “Mouse” becomes “mice” and “louse” becomes “lice”, but “house” becomes “houses”. “Knife” becomes “knives” and “wife” becomes “wives”, but “lowlife” becomes “lowlifes”. And don't even get me started on words that are their own plural, like “sheep”, “deer”, and “haiku”.)
 
    Other languages are, of course, completely different.
-
    Let's design a module that pluralizes nouns.  Start with just English nouns, and just these four rules, but keep in mind that
+
    Let's design a module that pluralizes nouns. Start with just English nouns, and just these four rules, but keep in mind that
 you'll inevitably need to add more rules, and you may eventually need to add more languages.
 
    17.2. plural.py, stage 1
    
-
    So you're looking at words, which at least in English are strings of characters.  And you have rules that say you need to
-   find different combinations of characters, and then do different things to them.  This sounds like a job for regular expressions.
+
    So you're looking at words, which at least in English are strings of characters. And you have rules that say you need to
+   find different combinations of characters, and then do different things to them. This sounds like a job for regular expressions.
 
    Example 17.1. plural1.py
     import re
 
@@ -14103,13 +13626,13 @@ def plural(noun):
 
 1 
 
-OK, this is a regular expression, but it uses a syntax you didn't see in Chapter 7, Regular Expressions.  The square brackets mean “match exactly one of these characters”.  So [sxz] means “s, or x, or z”, but only one of them.  The $ should be familiar; it matches the end of string.  So you're checking to see if noun ends with s, x, or z.
+OK, this is a regular expression, but it uses a syntax you didn't see in Chapter 7, Regular Expressions. The square brackets mean “match exactly one of these characters”. So [sxz] means “s, or x, or z”, but only one of them. The $ should be familiar; it matches the end of string. So you're checking to see if noun ends with s, x, or z.
 
 
 
 2 
 
-This re.sub function performs regular expression-based string substitutions.  Let's look at it in more detail.
+This re.sub function performs regular expression-based string substitutions. Let's look at it in more detail.
 
 
 
@@ -14134,7 +13657,7 @@ def plural(noun):
 
 2 
 
-OK, now find a, b, or c, and replace it with o.  Mark becomes Mork.
+OK, now find a, b, or c, and replace it with o. Mark becomes Mork.
 
 
 
@@ -14146,7 +13669,7 @@ def plural(noun):
 
 4 
 
-You might think this would turn caps into oaps, but it doesn't.  re.sub replaces all of the matches, not just the first one.  So this regular expression turns caps into oops, because both the c and the a get turned into o.
+You might think this would turn caps into oaps, but it doesn't. re.sub replaces all of the matches, not just the first one. So this regular expression turns caps into oops, because both the c and the a get turned into o.
 
 
 
@@ -14167,19 +13690,19 @@ def plural(noun):
 
 1 
 
-Back to the plural function.  What are you doing?  You're replacing the end of string with es.  In other words, adding es to the string.  You could accomplish the same thing with string concatenation, for example noun + 'es', but I'm using regular expressions for everything, for consistency, for reasons that will become clear later in the chapter.
+Back to the plural function. What are you doing?  You're replacing the end of string with es. In other words, adding es to the string. You could accomplish the same thing with string concatenation, for example noun + 'es', but I'm using regular expressions for everything, for consistency, for reasons that will become clear later in the chapter.
 
 
 
 2 
 
-Look closely, this is another new variation.  The ^ as the first character inside the square brackets means something special: negation.  [^abc] means “any single character except a, b, or c”.  So [^aeioudgkprt] means any character except a, e, i, o, u, d, g, k, p, r, or t.  Then that character needs to be followed by h, followed by end of string.  You're looking for words that end in H where the H can be heard.
+Look closely, this is another new variation. The ^ as the first character inside the square brackets means something special: negation. [^abc] means “any single character except a, b, or c”. So [^aeioudgkprt] means any character except a, e, i, o, u, d, g, k, p, r, or t. Then that character needs to be followed by h, followed by end of string. You're looking for words that end in H where the H can be heard.
 
 
 
 3 
 
-Same pattern here: match words that end in Y, where the character before the Y is not a, e, i, o, or u.  You're looking for words that end in Y that sounds like I.
+Same pattern here: match words that end in Y, where the character before the Y is not a, e, i, o, or u. You're looking for words that end in Y that sounds like I.
 
 
 
@@ -14204,7 +13727,7 @@ def plural(noun):
 
 2 
 
-boy does not match, because it ends in oy, and you specifically said that the character before the y could not be o.  day does not match, because it ends in ay.
+boy does not match, because it ends in oy, and you specifically said that the character before the y could not be o. day does not match, because it ends in ay.
 
 
 
@@ -14226,24 +13749,24 @@ def plural(noun):
 
 1 
 
-This regular expression turns vacancy into vacancies and agency into agencies, which is what you wanted.  Note that it would also turn boy into boies, but that will never happen in the function because you did that re.search first to find out whether you should do this re.sub.
+This regular expression turns vacancy into vacancies and agency into agencies, which is what you wanted. Note that it would also turn boy into boies, but that will never happen in the function because you did that re.search first to find out whether you should do this re.sub.
 
 
 
 2 
 
 Just in passing, I want to point out that it is possible to combine these two regular expressions (one to find out if the
-            rule applies, and another to actually apply it) into a single regular expression.  Here's what that would look like.  Most
-            of it should look familiar: you're using a remembered group, which you learned in Section 7.6, “Case study: Parsing Phone Numbers”, to remember the character before the y.  Then in the substitution string, you use a new syntax, \1, which means “hey, that first group you remembered?  put it here”.  In this case, you remember the c before the y, and then when you do the substitution, you substitute c in place of c, and ies in place of y.  (If you have more than one remembered group, you can use \2 and \3 and so on.)
+            rule applies, and another to actually apply it) into a single regular expression. Here's what that would look like. Most
+            of it should look familiar: you're using a remembered group, which you learned in Section 7.6, “Case study: Parsing Phone Numbers”, to remember the character before the y. Then in the substitution string, you use a new syntax, \1, which means “hey, that first group you remembered?  put it here”. In this case, you remember the c before the y, and then when you do the substitution, you substitute c in place of c, and ies in place of y. (If you have more than one remembered group, you can use \2 and \3 and so on.)
 
 
 
-
    Regular expression substitutions are extremely powerful, and the \1 syntax makes them even more powerful.  But combining the entire operation into one regular expression is also much harder
-to read, and it doesn't directly map to the way you first described the pluralizing rules.  You originally laid out rules
-like “if the word ends in S, X, or Z, then add ES”.  And if you look at this function, you have two lines of code that say “if the word ends in S, X, or Z, then add ES”.  It doesn't get much more direct than that.
+
    Regular expression substitutions are extremely powerful, and the \1 syntax makes them even more powerful. But combining the entire operation into one regular expression is also much harder
+to read, and it doesn't directly map to the way you first described the pluralizing rules. You originally laid out rules
+like “if the word ends in S, X, or Z, then add ES”. And if you look at this function, you have two lines of code that say “if the word ends in S, X, or Z, then add ES”. It doesn't get much more direct than that.
 
    17.3. plural.py, stage 2
    
-
    Now you're going to add a level of abstraction.  You started by defining a list of rules: if this, then do that, otherwise
-   go to the next rule.  Let's temporarily complicate part of the program so you can simplify another part.
+
    Now you're going to add a level of abstraction. You started by defining a list of rules: if this, then do that, otherwise
+   go to the next rule. Let's temporarily complicate part of the program so you can simplify another part.
 
    Example 17.6. plural2.py
     import re
 
@@ -14287,20 +13810,20 @@ def plural(noun):
 1 
 
 This version looks more complicated (it's certainly longer), but it does exactly the same thing: try to match four different
-            rules, in order, and apply the appropriate regular expression when a match is found.  The difference is that each individual
+            rules, in order, and apply the appropriate regular expression when a match is found. The difference is that each individual
             match and apply rule is defined in its own function, and the functions are then listed in this rules variable, which is a tuple of tuples.
 
 
 
 2 
 
-Using a for loop, you can pull out the match and apply rules two at a time (one match, one apply) from the rules tuple.  On the first iteration of the for loop, matchesRule will get match_sxz, and applyRule will get apply_sxz.  On the second iteration (assuming you get that far), matchesRule will be assigned match_h, and applyRule will be assigned apply_h.
+Using a for loop, you can pull out the match and apply rules two at a time (one match, one apply) from the rules tuple. On the first iteration of the for loop, matchesRule will get match_sxz, and applyRule will get apply_sxz. On the second iteration (assuming you get that far), matchesRule will be assigned match_h, and applyRule will be assigned apply_h.
 
 
 
 3 
 
-Remember that everything in Python is an object, including functions.  rules contains actual functions; not names of functions, but actual functions.  When they get assigned in the for loop, then matchesRule and applyRule are actual functions that you can call.  So on the first iteration of the for loop, this is equivalent to calling matches_sxz(noun).
+Remember that everything in Python is an object, including functions. rules contains actual functions; not names of functions, but actual functions. When they get assigned in the for loop, then matchesRule and applyRule are actual functions that you can call. So on the first iteration of the for loop, this is equivalent to calling matches_sxz(noun).
 
 
 
@@ -14310,7 +13833,7 @@ def plural(noun):
 
 
 
-
    If this additional level of abstraction is confusing, try unrolling the function to see the equivalence.  This for loop is equivalent to the following:
+
    If this additional level of abstraction is confusing, try unrolling the function to see the equivalence. This for loop is equivalent to the following:
 
    Example 17.7. Unrolling the plural function
     def plural(noun):
     if match_sxz(noun):
@@ -14321,14 +13844,14 @@ def plural(noun):
         return apply_y(noun)
     if match_default(noun):
         return apply_default(noun)
-
    The benefit here is that that plural function is now simplified.  It takes a list of rules, defined elsewhere, and iterates through them in a generic fashion.
-Get a match rule; does it match?  Then call the apply rule.  The rules could be defined anywhere, in any way.  The plural function doesn't care.
-
    Now, was adding this level of abstraction worth it?  Well, not yet.  Let's consider what it would take to add a new rule to
-the function.  Well, in the previous example, it would require adding an if statement to the plural function.  In this example, it would require adding two functions, match_foo and apply_foo, and then updating the rules list to specify where in the order the new match and apply functions should be called relative to the other rules.
-
    This is really just a stepping stone to the next section.  Let's move on.
+
    The benefit here is that that plural function is now simplified. It takes a list of rules, defined elsewhere, and iterates through them in a generic fashion.
+Get a match rule; does it match?  Then call the apply rule. The rules could be defined anywhere, in any way. The plural function doesn't care.
+
    Now, was adding this level of abstraction worth it?  Well, not yet. Let's consider what it would take to add a new rule to
+the function. Well, in the previous example, it would require adding an if statement to the plural function. In this example, it would require adding two functions, match_foo and apply_foo, and then updating the rules list to specify where in the order the new match and apply functions should be called relative to the other rules.
+
    This is really just a stepping stone to the next section. Let's move on.
 
    17.4. plural.py, stage 3
    
-
    Defining separate named functions for each match and apply rule isn't really necessary.  You never call them directly; you
-   define them in the rules list and call them through there.  Let's streamline the rules definition by anonymizing those functions.
+
    Defining separate named functions for each match and apply rule isn't really necessary. You never call them directly; you
+   define them in the rules list and call them through there. Let's streamline the rules definition by anonymizing those functions.
 
    Example 17.8. plural3.py
     import re
 
@@ -14361,22 +13884,22 @@ def plural(noun):
 
 1 
 
-This is the same set of rules as you defined in stage 2.  The only difference is that instead of defining named functions
+This is the same set of rules as you defined in stage 2. The only difference is that instead of defining named functions
             like match_sxz and apply_sxz, you have “inlined” those function definitions directly into the rules list itself, using lambda functions.
 
 
 
 2 
 
-Note that the plural function hasn't changed at all.  It iterates through a set of rule functions, checks the first rule, and if it returns a
-            true value, calls the second rule and returns the value.  Same as above, word for word.  The only difference is that the rule
-            functions were defined inline, anonymously, using lambda functions.  But the plural function doesn't care how they were defined; it just gets a list of rules and blindly works through them.
+Note that the plural function hasn't changed at all. It iterates through a set of rule functions, checks the first rule, and if it returns a
+            true value, calls the second rule and returns the value. Same as above, word for word. The only difference is that the rule
+            functions were defined inline, anonymously, using lambda functions. But the plural function doesn't care how they were defined; it just gets a list of rules and blindly works through them.
 
 
 
-
    Now to add a new rule, all you need to do is define the functions directly in the rules list itself: one match rule, and one apply rule.  But defining the rule functions inline like this makes it very clear that
-you have some unnecessary duplication here.  You have four pairs of functions, and they all follow the same pattern.  The
-match function is a single call to re.search, and the apply function is a single call to re.sub.  Let's factor out these similarities.
+
    Now to add a new rule, all you need to do is define the functions directly in the rules list itself: one match rule, and one apply rule. But defining the rule functions inline like this makes it very clear that
+you have some unnecessary duplication here. You have four pairs of functions, and they all follow the same pattern. The
+match function is a single call to re.search, and the apply function is a single call to re.sub. Let's factor out these similarities.
 
    17.5. plural.py, stage 4
    
 
    Let's factor out the duplication in the code so that defining new rules can be easier.
 
    Example 17.9. plural4.py
    @@ -14391,21 +13914,21 @@ def buildMatchAndApplyFunctions((pattern, search, replace)):
 
 1 
 
-buildMatchAndApplyFunctions is a function that builds other functions dynamically.  It takes pattern, search and replace (actually it takes a tuple, but more on that in a minute), and you can build the match function using the lambda syntax to be a function that takes one parameter (word) and calls re.search with the pattern that was passed to the buildMatchAndApplyFunctions function, and the word that was passed to the match function you're building.  Whoa.
+buildMatchAndApplyFunctions is a function that builds other functions dynamically. It takes pattern, search and replace (actually it takes a tuple, but more on that in a minute), and you can build the match function using the lambda syntax to be a function that takes one parameter (word) and calls re.search with the pattern that was passed to the buildMatchAndApplyFunctions function, and the word that was passed to the match function you're building. Whoa.
 
 
 
 2 
 
-Building the apply function works the same way.  The apply function is a function that takes one parameter, and calls re.sub with the search and replace parameters that were passed to the buildMatchAndApplyFunctions function, and the word that was passed to the apply function you're building.  This technique of using the values of outside parameters within a
-            dynamic function is called closures.  You're essentially defining constants within the apply function you're building: it takes one parameter (word), but it then acts on that plus two other values (search and replace) which were set when you defined the apply function.
+Building the apply function works the same way. The apply function is a function that takes one parameter, and calls re.sub with the search and replace parameters that were passed to the buildMatchAndApplyFunctions function, and the word that was passed to the apply function you're building. This technique of using the values of outside parameters within a
+            dynamic function is called closures. You're essentially defining constants within the apply function you're building: it takes one parameter (word), but it then acts on that plus two other values (search and replace) which were set when you defined the apply function.
 
 
 
 3 
 
-Finally, the buildMatchAndApplyFunctions function returns a tuple of two values: the two functions you just created.  The constants you defined within those functions
-            (pattern within matchFunction, and search and replace within applyFunction) stay with those functions, even after you return from buildMatchAndApplyFunctions.  That's insanely cool.
+Finally, the buildMatchAndApplyFunctions function returns a tuple of two values: the two functions you just created. The constants you defined within those functions
+            (pattern within matchFunction, and search and replace within applyFunction) stay with those functions, even after you return from buildMatchAndApplyFunctions. That's insanely cool.
 
 
 
@@ -14424,19 +13947,19 @@ rules = map(buildMatchAndApplyFunctions, patterns)  
 1 
 
-Our pluralization rules are now defined as a series of strings (not functions).  The first string is the regular expression
+Our pluralization rules are now defined as a series of strings (not functions). The first string is the regular expression
             that you would use in re.search to see if this rule matches; the second and third are the search and replace expressions you would use in re.sub to actually apply the rule to turn a noun into its plural.
 
 
 
 2 
 
-This line is magic.  It takes the list of strings in patterns and turns them into a list of functions.  How?  By mapping the strings to the buildMatchAndApplyFunctions function, which just happens to take three strings as parameters and return a tuple of two functions.  This means that rules ends up being exactly the same as the previous example: a list of tuples, where each tuple is a pair of functions, where
+This line is magic. It takes the list of strings in patterns and turns them into a list of functions. How?  By mapping the strings to the buildMatchAndApplyFunctions function, which just happens to take three strings as parameters and return a tuple of two functions. This means that rules ends up being exactly the same as the previous example: a list of tuples, where each tuple is a pair of functions, where
             the first function is the match function that calls re.search, and the second function is the apply function that calls re.sub.
 
 
 
-
    I swear I am not making this up: rules ends up with exactly the same list of functions as the previous example.  Unroll the rules definition, and you'll get this:
+
    I swear I am not making this up: rules ends up with exactly the same list of functions as the previous example. Unroll the rules definition, and you'll get this:
 
    Example 17.11. Unrolling the rules definition
     rules = \
   (
@@ -14467,12 +13990,12 @@ def plural(noun):
 
 1 
 
-Since the rules list is the same as the previous example, it should come as no surprise that the plural function hasn't changed.  Remember, it's completely generic; it takes a list of rule functions and calls them in order. 
-            It doesn't care how the rules are defined.  In stage 2, they were defined as seperate named functions.  In stage 3, they were defined as anonymous lambda functions.  Now in stage 4, they are built dynamically by mapping the buildMatchAndApplyFunctions function onto a list of raw strings.  Doesn't matter; the plural function still works the same way.
+Since the rules list is the same as the previous example, it should come as no surprise that the plural function hasn't changed. Remember, it's completely generic; it takes a list of rule functions and calls them in order. 
+            It doesn't care how the rules are defined. In stage 2, they were defined as seperate named functions. In stage 3, they were defined as anonymous lambda functions. Now in stage 4, they are built dynamically by mapping the buildMatchAndApplyFunctions function onto a list of raw strings. Doesn't matter; the plural function still works the same way.
 
 
 
-
    Just in case that wasn't mind-blowing enough, I must confess that there was a subtlety in the definition of buildMatchAndApplyFunctions that I skipped over.  Let's go back and take another look.
+
    Just in case that wasn't mind-blowing enough, I must confess that there was a subtlety in the definition of buildMatchAndApplyFunctions that I skipped over. Let's go back and take another look.
 
    Example 17.13. Another look at buildMatchAndApplyFunctions
     def buildMatchAndApplyFunctions((pattern, search, replace)):   1
 
    
@@ -14481,16 +14004,16 @@ def buildMatchAndApplyFunctions((pattern, search, replace)):   1 
 
 Notice the double parentheses?  This function doesn't actually take three parameters; it actually takes one parameter, a tuple
-            of three elements.  But the tuple is expanded when the function is called, and the three elements of the tuple are each assigned
-            to different variables: pattern, search, and replace.  Confused yet?  Let's see it in action.
+            of three elements. But the tuple is expanded when the function is called, and the three elements of the tuple are each assigned
+            to different variables: pattern, search, and replace. Confused yet?  Let's see it in action.
 
 
 
 
    Example 17.14. Expanding tuples when calling functions
     >>> def foo((a, b, c)):
-...     print c
-...     print b
-...     print a
+...    print c
+...    print b
+...    print a
 >>> parameters = ('apple', 'bear', 'catnap')
 >>> foo(parameters) 1
 catnap
@@ -14501,19 +14024,19 @@ apple
 
 1 
 
-The proper way to call the function foo is with a tuple of three elements.  When the function is called, the elements are assigned to different local variables within
+The proper way to call the function foo is with a tuple of three elements. When the function is called, the elements are assigned to different local variables within
 foo.
 
 
 
-
    Now let's go back and see why this auto-tuple-expansion trick was necessary.  patterns was a list of tuples, and each tuple had three elements.  When you called map(buildMatchAndApplyFunctions, patterns), that means that buildMatchAndApplyFunctions is not getting called with three parameters.  Using map to map a single list onto a function always calls the function with a single parameter: each element of the list.  In the
+
    Now let's go back and see why this auto-tuple-expansion trick was necessary. patterns was a list of tuples, and each tuple had three elements. When you called map(buildMatchAndApplyFunctions, patterns), that means that buildMatchAndApplyFunctions is not getting called with three parameters. Using map to map a single list onto a function always calls the function with a single parameter: each element of the list. In the
    case of patterns, each element of the list is a tuple, so buildMatchAndApplyFunctions always gets called with the tuple, and you use the auto-tuple-expansion trick in the definition of buildMatchAndApplyFunctions to assign the elements of that tuple to named variables that you can work with.
 
    17.6. plural.py, stage 5
    
 
    You've factored out all the duplicate code and added enough abstractions so that the pluralization rules are defined in a
-   list of strings.  The next logical step is to take these strings and put them in a separate file, where they can be maintained
+   list of strings. The next logical step is to take these strings and put them in a separate file, where they can be maintained
    separately from the code that uses them.
-
    First, let's create a text file that contains the rules you want.  No fancy data structures, just space- (or tab-)delimited
-strings in three columns.  You'll call it rules.en; “en” stands for English.  These are the rules for pluralizing English nouns.  You could add other rule files for other languages
+
    First, let's create a text file that contains the rules you want. No fancy data structures, just space- (or tab-)delimited
+strings in three columns. You'll call it rules.en; “en” stands for English. These are the rules for pluralizing English nouns. You could add other rule files for other languages
 later.
 
    Example 17.15. rules.en
     [sxz]$$               es
@@ -14541,7 +14064,7 @@ def plural(noun, language='en'):           1 
 
 You're still using the closures technique here (building a function dynamically that uses variables defined outside the function),
-            but now you've combined the separate match and apply functions into one.  (The reason for this change will become clear in
+            but now you've combined the separate match and apply functions into one. (The reason for this change will become clear in
             the next section.)  This will let you accomplish the same thing as having two functions, but you'll need to call it differently,
             as you'll see in a minute.
 
@@ -14555,7 +14078,7 @@ def plural(noun, language='en'):           3 
 
-You use the language parameter to construct a filename, then open the file and read the contents into a list.  If language is en, then you'll open the rules.en file, read the entire thing, break it up by carriage returns, and return a list.  Each line of the file will be one element
+You use the language parameter to construct a filename, then open the file and read the contents into a list. If language is en, then you'll open the rules.en file, read the entire thing, break it up by carriage returns, and return a list. Each line of the file will be one element
             in the list.
 
 
@@ -14563,27 +14086,27 @@ def plural(noun, language='en'):           4 
 
 As you saw, each line in the file really has three values, but they're separated by whitespace (tabs or spaces, it makes no
-            difference).  Mapping the string.split function onto this list will create a new list where each element is a tuple of three strings.  So a line like [sxz]$ $ es will be broken up into the tuple ('[sxz]$', '$', 'es').  This means that patterns will end up as a list of tuples, just like you hard-coded it in stage 4.
+            difference). Mapping the string.split function onto this list will create a new list where each element is a tuple of three strings. So a line like [sxz]$ $ es will be broken up into the tuple ('[sxz]$', '$', 'es'). This means that patterns will end up as a list of tuples, just like you hard-coded it in stage 4.
 
 
 
 5 
 
-If patterns is a list of tuples, then rules will be a list of the functions created dynamically by each call to buildRule.  Calling buildRule(('[sxz]$', '$', 'es')) returns a function that takes a single parameter, word.  When this returned function is called, it will execute re.search('[sxz]$', word) and re.sub('$', 'es', word).
+If patterns is a list of tuples, then rules will be a list of the functions created dynamically by each call to buildRule. Calling buildRule(('[sxz]$', '$', 'es')) returns a function that takes a single parameter, word. When this returned function is called, it will execute re.search('[sxz]$', word) and re.sub('$', 'es', word).
 
 
 
 6 
 
-Because you're now building a combined match-and-apply function, you need to call it differently.  Just call the function,
+Because you're now building a combined match-and-apply function, you need to call it differently. Just call the function,
             and if it returns something, then that's the plural; if it returns nothing (None), then the rule didn't match and you need to try another rule.
 
 
 
-
    So the improvement here is that you've completely separated the pluralization rules into an external file.  Not only can the
+
    So the improvement here is that you've completely separated the pluralization rules into an external file. Not only can the
 file be maintained separately from the code, but you've set up a naming scheme where the same plural function can use different rule files, based on the language parameter.
-
    The downside here is that you're reading that file every time you call the plural function.  I thought I could get through this entire book without using the phrase “left as an exercise for the reader”, but here you go: building a caching mechanism for the language-specific rule files that auto-refreshes itself if the rule
-files change between calls is left as an exercise for the reader.  Have fun.
+
    The downside here is that you're reading that file every time you call the plural function. I thought I could get through this entire book without using the phrase “left as an exercise for the reader”, but here you go: building a caching mechanism for the language-specific rule files that auto-refreshes itself if the rule
+files change between calls is left as an exercise for the reader. Have fun.
 
    17.7. plural.py, stage 6
    
 
    Now you're ready to talk about generators.
 
    Example 17.17. plural6.py
    @@ -14601,12 +14124,12 @@ def plural(noun, language='en'):
 
    This uses a technique called generators, which I'm not even going to try to explain until you look at a simpler example first.
 
    Example 17.18. Introducing generators
     >>> def make_counter(x):
-...     print 'entering make_counter'
-...     while 1:
-...         yield x               1
-...         print 'incrementing x'
-...         x = x + 1
-...     
+...    print 'entering make_counter'
+...    while 1:
+...        yield x               1
+...        print 'incrementing x'
+...        x = x + 1
+...    
 >>> counter = make_counter(2) 2
 >>> counter 3
 <generator object at 0x001C9C10>
@@ -14624,15 +14147,15 @@ def plural(noun, language='en'):
 
 1 
 
-The presence of the yield keyword in make_counter means that this is not a normal function.  It is a special kind of function which generates values one at a time.  You can
-            think of it as a resumable function.  Calling it will return a generator that can be used to generate successive values of
+The presence of the yield keyword in make_counter means that this is not a normal function. It is a special kind of function which generates values one at a time. You can
+            think of it as a resumable function. Calling it will return a generator that can be used to generate successive values of
 x.
 
 
 
 2 
 
-To create an instance of the make_counter generator, just call it like any other function.  Note that this does not actually execute the function code.  You can tell
+To create an instance of the make_counter generator, just call it like any other function. Note that this does not actually execute the function code. You can tell
             this because the first line of make_counter is a print statement, but nothing has been printed yet.
 
 
@@ -14645,19 +14168,19 @@ def plural(noun, language='en'):
 
 4 
 
-The first time you call the next() method on the generator object, it executes the code in make_counter up to the first yield statement, and then returns the value that was yielded.  In this case, that will be 2, because you originally created the generator by calling make_counter(2).
+The first time you call the next() method on the generator object, it executes the code in make_counter up to the first yield statement, and then returns the value that was yielded. In this case, that will be 2, because you originally created the generator by calling make_counter(2).
 
 
 
 5 
 
-Repeatedly calling next() on the generator object resumes where you left off and continues until you hit the next yield statement.  The next line of code waiting to be executed is the print statement that prints incrementing x, and then after that the x = x + 1 statement that actually increments it.  Then you loop through the while loop again, and the first thing you do is yield x, which returns the current value of x (now 3).
+Repeatedly calling next() on the generator object resumes where you left off and continues until you hit the next yield statement. The next line of code waiting to be executed is the print statement that prints incrementing x, and then after that the x = x + 1 statement that actually increments it. Then you loop through the while loop again, and the first thing you do is yield x, which returns the current value of x (now 3).
 
 
 
 6 
 
-The second time you call counter.next(), you do all the same things again, but this time x is now 4.  And so forth.  Since make_counter sets up an infinite loop, you could theoretically do this forever, and it would just keep incrementing x and spitting out values.  But let's look at more productive uses of generators instead.
+The second time you call counter.next(), you do all the same things again, but this time x is now 4. And so forth. Since make_counter sets up an infinite loop, you could theoretically do this forever, and it would just keep incrementing x and spitting out values. But let's look at more productive uses of generators instead.
 
 
 
@@ -14672,8 +14195,8 @@ def fibonacci(max):
 
 1 
 
-The Fibonacci sequence is a sequence of numbers where each number is the sum of the two numbers before it.  It starts with
-0 and 1, goes up slowly at first, then more and more rapidly.  To start the sequence, you need two variables: a starts at 0, and b starts at 1.
+The Fibonacci sequence is a sequence of numbers where each number is the sum of the two numbers before it. It starts with
+0 and 1, goes up slowly at first, then more and more rapidly. To start the sequence, you need two variables: a starts at 0, and b starts at 1.
 
 
 
@@ -14685,28 +14208,28 @@ def fibonacci(max):
 
 3 
 
-b is the next number in the sequence, so assign that to a, but also calculate the next value (a+b) and assign that to b for later use.  Note that this happens in parallel; if a is 3 and b is 5, then a, b = b, a+b will set a to 5 (the previous value of b) and b to 8 (the sum of the previous values of a and b).
+b is the next number in the sequence, so assign that to a, but also calculate the next value (a+b) and assign that to b for later use. Note that this happens in parallel; if a is 3 and b is 5, then a, b = b, a+b will set a to 5 (the previous value of b) and b to 8 (the sum of the previous values of a and b).
 
 
 
-
    So you have a function that spits out successive Fibonacci numbers.  Sure, you could do that with recursion, but this way
-is easier to read.  Also, it works well with for loops.
+
    So you have a function that spits out successive Fibonacci numbers. Sure, you could do that with recursion, but this way
+is easier to read. Also, it works well with for loops.
 
    Example 17.20. Generators in for loops
     >>> for n in fibonacci(1000): 1
-...     print n,              2
+...    print n,              2
 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
 
    
 
-
-
    
 
    
 1 
 You can use a generator like fibonacci in a for loop directly.  The for loop will create the generator object and successively call the next() method to get values to assign to the for loop index variable (n).
+You can use a generator like fibonacci in a for loop directly. The for loop will create the generator object and successively call the next() method to get values to assign to the for loop index variable (n).
 
 
    
 
    
 2 
 Each time through the for loop, n gets a new value from the yield statement in fibonacci, and all you do is print it out.  Once fibonacci runs out of numbers (a gets bigger than max, which in this case is 1000), then the for loop exits gracefully.
+Each time through the for loop, n gets a new value from the yield statement in fibonacci, and all you do is print it out. Once fibonacci runs out of numbers (a gets bigger than max, which in this case is 1000), then the for loop exits gracefully.
 
 
    
 
    
@@ -14726,27 +14249,27 @@ def plural(noun, language='en'):
 
 1 
 
-for line in file(...) is a common idiom for reading lines from a file, one line at a time.  It works because file actually returns a generator whose next() method returns the next line of the file.  That is so insanely cool, I wet myself just thinking about it.
+for line in file(...) is a common idiom for reading lines from a file, one line at a time. It works because file actually returns a generator whose next() method returns the next line of the file. That is so insanely cool, I wet myself just thinking about it.
 
 
 
 2 
 
-No magic here.  Remember that the lines of the rules file have three values separated by whitespace, so line.split() returns a tuple of 3 values, and you assign those values to 3 local variables.
+No magic here. Remember that the lines of the rules file have three values separated by whitespace, so line.split() returns a tuple of 3 values, and you assign those values to 3 local variables.
 
 
 
 3 
 
-And then you yield.  What do you yield?  A function, built dynamically with lambda, that is actually a closure (it uses the local variables pattern, search, and replace as constants).  In other words, rules is a generator that spits out rule functions.
+And then you yield.  What do you yield?  A function, built dynamically with lambda, that is actually a closure (it uses the local variables pattern, search, and replace as constants). In other words, rules is a generator that spits out rule functions.
 
 
 
 4 
 
-Since rules is a generator, you can use it directly in a for loop.  The first time through the for loop, you will call the rules function, which will open the rules file, read the first line out of it, dynamically build a function that matches and applies
-            the first rule defined in the rules file, and yields the dynamically built function.  The second time through the for loop, you will pick up where you left off in rules (which was in the middle of the for line in file(...) loop), read the second line of the rules file, dynamically build another function that matches and applies the second rule
-            defined in the rules file, and yields it.  And so forth.
+Since rules is a generator, you can use it directly in a for loop. The first time through the for loop, you will call the rules function, which will open the rules file, read the first line out of it, dynamically build a function that matches and applies
+            the first rule defined in the rules file, and yields the dynamically built function. The second time through the for loop, you will pick up where you left off in rules (which was in the middle of the for line in file(...) loop), read the second line of the rules file, dynamically build another function that matches and applies the second rule
+            defined in the rules file, and yields it. And so forth.
 
 
 
@@ -14762,7 +14285,7 @@ it, but if that works you don't ever read the rest of the file or create any oth
 
 
 
    17.8. Summary
    
-
    You talked about several different advanced techniques in this chapter.  Not all of them are appropriate for every situation.
+
    You talked about several different advanced techniques in this chapter. Not all of them are appropriate for every situation.
 
    You should now be comfortable with all of these techniques:
 
    
 
      
@@ -14778,27 +14301,27 @@ it, but if that works you don't ever read the rest of the file or create any oth
 
 
    
 
    Adding abstractions, building functions dynamically, building closures, and using generators can all make your code simpler,
-more readable, and more flexible.  But they can also end up making it more difficult to debug later.  It's up to you to find
+more readable, and more flexible. But they can also end up making it more difficult to debug later. It's up to you to find
 the right balance between simplicity and power.
 
    
 
    Chapter 18. Performance Tuning
    
-
    Performance tuning is a many-splendored thing.  Just because Python is an interpreted language doesn't mean you shouldn't worry about code optimization.  But don't worry about it too much.
+
    Performance tuning is a many-splendored thing. Just because Python is an interpreted language doesn't mean you shouldn't worry about code optimization. But don't worry about it too much.
 
    18.1. Diving in
    
 
    There are so many pitfalls involved in optimizing your code, it's hard to know where to start.
 
    Let's start here: are you sure you need to do it at all?  Is your code really so bad?  Is it worth the time to tune it?  Over the lifetime of your application, how much time is going
 to be spent running that code, compared to the time spent waiting for a remote database server, or waiting for user input?
-
    Second, are you sure you're done coding?  Premature optimization is like spreading frosting on a half-baked cake.  You spend hours or days (or more) optimizing your
-code for performance, only to discover it doesn't do what you need it to do.  That's time down the drain.
+
    Second, are you sure you're done coding?  Premature optimization is like spreading frosting on a half-baked cake. You spend hours or days (or more) optimizing your
+code for performance, only to discover it doesn't do what you need it to do. That's time down the drain.
 
    This is not to say that code optimization is worthless, but you need to look at the whole system and decide whether it's the
-best use of your time.  Every minute you spend optimizing code is a minute you're not spending adding new features, or writing
+best use of your time. Every minute you spend optimizing code is a minute you're not spending adding new features, or writing
 documentation, or playing with your kids, or writing unit tests.
-
    Oh yes, unit tests.  It should go without saying that you need a complete set of unit tests before you begin performance tuning.
+
    Oh yes, unit tests. It should go without saying that you need a complete set of unit tests before you begin performance tuning.
 The last thing you need is to introduce new bugs while fiddling with your algorithms.
-
    With these caveats in place, let's look at some techniques for optimizing Python code.  The code in question is an implementation of the Soundex algorithm.  Soundex was a method used in the early 20th century
-for categorizing surnames in the United States census.  It grouped similar-sounding names together, so even if a name was
-misspelled, researchers had a chance of finding it.  Soundex is still used today for much the same reason, although of course
-we use computerized database servers now.  Most database servers include a Soundex function.
-
    There are several subtle variations of the Soundex algorithm.  This is the one used in this chapter:
+
    With these caveats in place, let's look at some techniques for optimizing Python code. The code in question is an implementation of the Soundex algorithm. Soundex was a method used in the early 20th century
+for categorizing surnames in the United States census. It grouped similar-sounding names together, so even if a name was
+misspelled, researchers had a chance of finding it. Soundex is still used today for much the same reason, although of course
+we use computerized database servers now. Most database servers include a Soundex function.
+
    There are several subtle variations of the Soundex algorithm. This is the one used in this chapter:
 
    
 
      
 
    1. Keep the first letter of the name as-is.
@@ -14819,7 +14342,7 @@ we use computerized database servers now.  Most database servers include a Sound
 
    2. If the result is shorter than four characters (the first letter plus three digits), pad the result with trailing zeros.
 
    3. if the result is longer than four characters, discard everything after the fourth character.
 
    
-
    For example, my name, Pilgrim, becomes P942695.  That has no consecutive duplicates, so nothing to do there.  Then you remove the 9s, leaving P4265.  That's
+
    For example, my name, Pilgrim, becomes P942695. That has no consecutive duplicates, so nothing to do there. Then you remove the 9s, leaving P4265. That's
 too long, so you discard the excess character, leaving P426.
 
    Another example: Woo becomes W99, which becomes W9, which becomes W, which gets padded with zeros to become W000.
 
    Here's a first attempt at a Soundex function:
@@ -14905,21 +14428,21 @@ if __name__ == '__main__':
 
 
    18.2. Using the timeit Module
    
 
    The most important thing you need to know about optimizing Python code is that you shouldn't write your own timing function.
-
    Timing short pieces of code is incredibly complex.  How much processor time is your computer devoting to running this code?
+
    Timing short pieces of code is incredibly complex. How much processor time is your computer devoting to running this code?
 Are there things running in the background?  Are you sure?  Every modern computer has background processes running, some all
-the time, some intermittently.  Cron jobs fire off at consistent intervals; background services occasionally “wake up” to do useful things like check for new mail, connect to instant messaging servers, check for application updates, scan for
-viruses, check whether a disk has been inserted into your CD drive in the last 100 nanoseconds, and so on.  Before you start
-your timing tests, turn everything off and disconnect from the network.  Then turn off all the things you forgot to turn off
+the time, some intermittently. Cron jobs fire off at consistent intervals; background services occasionally “wake up” to do useful things like check for new mail, connect to instant messaging servers, check for application updates, scan for
+viruses, check whether a disk has been inserted into your CD drive in the last 100 nanoseconds, and so on. Before you start
+your timing tests, turn everything off and disconnect from the network. Then turn off all the things you forgot to turn off
 the first time, then turn off the service that's incessantly checking whether the network has come back yet, then ...
-
    And then there's the matter of the variations introduced by the timing framework itself.  Does the Python interpreter cache method name lookups?  Does it cache code block compilations?  Regular expressions?  Will your code have
+
    And then there's the matter of the variations introduced by the timing framework itself. Does the Python interpreter cache method name lookups?  Does it cache code block compilations?  Regular expressions?  Will your code have
 side effects if run more than once?  Don't forget that you're dealing with small fractions of a second, so small mistakes
 in your timing framework will irreparably skew your results.
-
    The Python community has a saying: “Python comes with batteries included.”  Don't write your own timing framework.  Python 2.3 comes with a perfectly good one called timeit.
+
    The Python community has a saying: “Python comes with batteries included.”  Don't write your own timing framework. Python 2.3 comes with a perfectly good one called timeit.
 
    Example 18.2. Introducing timeit
    
 
    If you have not already done so, you can download this and other examples used in this book.
     >>> import timeit
 >>> t = timeit.Timer("soundex.soundex('Pilgrim')",
-...     "import soundex")   1
+...    "import soundex")   1
 >>> t.timeit()              2
 8.21683733547
 >>> t.repeat(3, 2000000)    3
@@ -14929,8 +14452,8 @@ in your timing framework will irreparably skew your results.
 
 1 
 
-The timeit module defines one class, Timer, which takes two arguments.  Both arguments are strings.  The first argument is the statement you wish to time; in this case,
-            you are timing a call to the Soundex function within the soundex with an argument of 'Pilgrim'.  The second argument to the Timer class is the import statement that sets up the environment for the statement.  Internally, timeit sets up an isolated virtual environment, manually executes the setup statement (importing the soundex module), then manually compiles and executes the timed statement (calling the Soundex function).
+The timeit module defines one class, Timer, which takes two arguments. Both arguments are strings. The first argument is the statement you wish to time; in this case,
+            you are timing a call to the Soundex function within the soundex with an argument of 'Pilgrim'. The second argument to the Timer class is the import statement that sets up the environment for the statement. Internally, timeit sets up an isolated virtual environment, manually executes the setup statement (importing the soundex module), then manually compiles and executes the timed statement (calling the Soundex function).
 
 
 
@@ -14942,9 +14465,9 @@ in your timing framework will irreparably skew your results.
 
 3 
 
-The other major method of the Timer object is repeat(), which takes two optional arguments.  The first argument is the number of times to repeat the entire test, and the second
-            argument is the number of times to call the timed statement within each test.  Both arguments are optional, and they default
-            to 3 and 1000000 respectively.  The repeat() method returns a list of the times each test cycle took, in seconds.
+The other major method of the Timer object is repeat(), which takes two optional arguments. The first argument is the number of times to repeat the entire test, and the second
+            argument is the number of times to call the timed statement within each test. Both arguments are optional, and they default
+            to 3 and 1000000 respectively. The repeat() method returns a list of the times each test cycle took, in seconds.
 
 
 
@@ -14953,16 +14476,16 @@ in your timing framework will irreparably skew your results.
 Tip
 
 
-You can use the timeit module on the command line to test an existing Python program, without modifying the code.  See http://docs.python.org/lib/node396.html for documentation on the command-line flags.
+You can use the timeit module on the command line to test an existing Python program, without modifying the code. See http://docs.python.org/lib/node396.html for documentation on the command-line flags.
 
 
 
-
    Note that repeat() returns a list of times.  The times will almost never be identical, due to slight variations in how much processor time the
-Python interpreter is getting (and those pesky background processes that you can't get rid of).  Your first thought might be to
+
    Note that repeat() returns a list of times. The times will almost never be identical, due to slight variations in how much processor time the
+Python interpreter is getting (and those pesky background processes that you can't get rid of). Your first thought might be to
 say “Let's take the average and call that The True Number.”
-
    In fact, that's almost certainly wrong.  The tests that took longer didn't take longer because of variations in your code
-or in the Python interpreter; they took longer because of those pesky background processes, or other factors outside of the Python interpreter that you can't fully eliminate.  If the different timing results differ by more than a few percent, you still
-have too much variability to trust the results.  Otherwise, take the minimum time and discard the rest.
+
    In fact, that's almost certainly wrong. The tests that took longer didn't take longer because of variations in your code
+or in the Python interpreter; they took longer because of those pesky background processes, or other factors outside of the Python interpreter that you can't fully eliminate. If the different timing results differ by more than a few percent, you still
+have too much variability to trust the results. Otherwise, take the minimum time and discard the rest.
 
    Python has a handy min function that takes a list and returns the smallest value:
 
     >>> min(t.repeat(3, 1000000))
@@ -14972,14 +14495,14 @@ have too much variability to trust the results.  Otherwise, take the minimum tim
 Tip
 
 
-The timeit module only works if you already know what piece of code you need to optimize.  If you have a larger Python program and don't know where your performance problems are, check out the hotshot module.
+The timeit module only works if you already know what piece of code you need to optimize. If you have a larger Python program and don't know where your performance problems are, check out the hotshot module.
 
 
 
    18.3. Optimizing Regular Expressions
    
-
    The first thing the Soundex function checks is whether the input is a non-empty string of letters.  What's the best way to
+
    The first thing the Soundex function checks is whether the input is a non-empty string of letters. What's the best way to
    do this?
-
    If you answered “regular expressions”, go sit in the corner and contemplate your bad instincts.  Regular expressions are almost never the right answer; they should
-be avoided whenever possible.  Not only for performance reasons, but simply because they're difficult to debug and maintain.
+
    If you answered “regular expressions”, go sit in the corner and contemplate your bad instincts. Regular expressions are almost never the right answer; they should
+be avoided whenever possible. Not only for performance reasons, but simply because they're difficult to debug and maintain.
 Also for performance reasons.
 
    This code fragment from soundex/stage1/soundex1a.py checks whether the function argument source is a word made entirely of letters, with at least one letter (not the empty string):
 
    @@ -15002,13 +14525,13 @@ if __name__ == '__main__':
 Woo             W000 19.3356647283
 Pilgrim         P426 24.0772053431
 Flingjingwaller F452 35.0463220884
-
    As you might expect, the algorithm takes significantly longer when called with longer names.  There will be a few things we
+
    As you might expect, the algorithm takes significantly longer when called with longer names. There will be a few things we
 can do to narrow that gap (make the function take less relative time for longer input), but the nature of the algorithm dictates
 that it will never run in constant time.
-
    The other thing to keep in mind is that we are testing a representative sample of names.  Woo is a kind of trivial case, in that it gets shorted down to a single letter and then padded with zeros.  Pilgrim is a normal case, of average length and a mixture of significant and ignored letters.  Flingjingwaller is extraordinarily long and contains consecutive duplicates.  Other tests might also be helpful, but this hits a good range
+
    The other thing to keep in mind is that we are testing a representative sample of names. Woo is a kind of trivial case, in that it gets shorted down to a single letter and then padded with zeros. Pilgrim is a normal case, of average length and a mixture of significant and ignored letters. Flingjingwaller is extraordinarily long and contains consecutive duplicates. Other tests might also be helpful, but this hits a good range
 of different cases.
-
    So what about that regular expression?  Well, it's inefficient.  Since the expression is testing for ranges of characters
-(A-Z in uppercase, and a-z in lowercase), we can use a shorthand regular expression syntax.  Here is soundex/stage1/soundex1b.py:
+
    So what about that regular expression?  Well, it's inefficient. Since the expression is testing for ranges of characters
+(A-Z in uppercase, and a-z in lowercase), we can use a shorthand regular expression syntax. Here is soundex/stage1/soundex1b.py:
 
         if not re.search('^[A-Za-z]+$', source):
         return "0000"
@@ -15018,8 +14541,8 @@ of different cases.
 Woo             W000 17.1361133887
 Pilgrim         P426 21.8201693232
 Flingjingwaller F452 32.7262294509
-
    We saw in Section 15.3, “Refactoring” that regular expressions can be compiled and reused for faster results.  Since this regular expression never changes across
-function calls, we can compile it once and use the compiled version.  Here is soundex/stage1/soundex1c.py:
+
    We saw in Section 15.3, “Refactoring” that regular expressions can be compiled and reused for faster results. Since this regular expression never changes across
+function calls, we can compile it once and use the compiled version. Here is soundex/stage1/soundex1c.py:
 
     isOnlyChars = re.compile('^[A-Za-z]+$').search
 def soundex(source):
@@ -15031,7 +14554,7 @@ def soundex(source):
 Woo             W000 14.5348347346
 Pilgrim         P426 19.2784703084
 Flingjingwaller F452 30.0893873383
-
    But is this the wrong path?  The logic here is simple: the input source needs to be non-empty, and it needs to be composed entirely of letters.  Wouldn't it be faster to write a loop checking each
+
    But is this the wrong path?  The logic here is simple: the input source needs to be non-empty, and it needs to be composed entirely of letters. Wouldn't it be faster to write a loop checking each
 character, and do away with regular expressions altogether?
 
    Here is soundex/stage1/soundex1d.py:
 
    @@ -15046,10 +14569,10 @@ character, and do away with regular expressions altogether?
 Woo             W000 15.4065058548
 Pilgrim         P426 22.2753567842
 Flingjingwaller F452 37.5845122774
-
    Why isn't soundex1d.py faster?  The answer lies in the interpreted nature of Python.  The regular expression engine is written in C, and compiled to run natively on your computer.  On the other hand, this
-loop is written in Python, and runs through the Python interpreter.  Even though the loop is relatively simple, it's not simple enough to make up for the overhead of being interpreted.
+
    Why isn't soundex1d.py faster?  The answer lies in the interpreted nature of Python. The regular expression engine is written in C, and compiled to run natively on your computer. On the other hand, this
+loop is written in Python, and runs through the Python interpreter. Even though the loop is relatively simple, it's not simple enough to make up for the overhead of being interpreted.
 Regular expressions are never the right answer... except when they are.
-
    It turns out that Python offers an obscure string method.  You can be excused for not knowing about it, since it's never been mentioned in this book.
+
    It turns out that Python offers an obscure string method. You can be excused for not knowing about it, since it's never been mentioned in this book.
 The method is called isalpha(), and it checks whether a string contains only letters.
 
    This is soundex/stage1/soundex1e.py:
 
    @@ -15116,10 +14639,10 @@ if __name__ == '__main__':
         t = Timer(statement, "from __main__ import soundex")
         print name.ljust(15), soundex(name), min(t.repeat())
 
    18.4. Optimizing Dictionary Lookups
    
-
    The second step of the Soundex algorithm is to convert characters to digits in a specific pattern.  What's the best way to
+
    The second step of the Soundex algorithm is to convert characters to digits in a specific pattern. What's the best way to
    do this?
 
    The most obvious solution is to define a dictionary with individual characters as keys and their corresponding digits as values,
-and do dictionary lookups on each character.  This is what we have in soundex/stage1/soundex1c.py (the current best result so far):
+and do dictionary lookups on each character. This is what we have in soundex/stage1/soundex1c.py (the current best result so far):
 
     charToSoundex = {"A": "9",
                  "B": "1",
@@ -15162,8 +14685,8 @@ def soundex(source):
 Pilgrim         P426 19.2650071448
 Flingjingwaller F452 30.1003563302
 
    This code is straightforward, but is it the best solution?  Calling upper() on each individual character seems inefficient; it would probably be better to call upper() once on the entire string.
-
    Then there's the matter of incrementally building the digits string.  Incrementally building strings like this is horribly inefficient; internally, the Python interpreter needs to create a new string each time through the loop, then discard the old one.
-
    Python is good at lists, though.  It can treat a string as a list of characters automatically.  And lists are easy to combine into
+
    Then there's the matter of incrementally building the digits string. Incrementally building strings like this is horribly inefficient; internally, the Python interpreter needs to create a new string each time through the loop, then discard the old one.
+
    Python is good at lists, though. It can treat a string as a list of characters automatically. And lists are easy to combine into
 strings again, using the string method join().
 
    Here is soundex/stage2/soundex2a.py, which converts letters to digits by using ↦ and lambda:
 
    @@ -15188,8 +14711,8 @@ Flingjingwaller F452 29.3790847719
 Woo             W000 13.4221324219
 Pilgrim         P426 16.4901234654
 Flingjingwaller F452 25.8186157738
-
    It's time for a radically different approach.  Dictionary lookups are a general purpose tool.  Dictionary keys can be any
-length string (or many other data types), but in this case we are only dealing with single-character keys and single-character values.  It turns out that Python has a specialized function for handling exactly this situation: the string.maketrans function.
+
    It's time for a radically different approach. Dictionary lookups are a general purpose tool. Dictionary keys can be any
+length string (or many other data types), but in this case we are only dealing with single-character keys and single-character values. It turns out that Python has a specialized function for handling exactly this situation: the string.maketrans function.
 
    This is soundex/stage2/soundex2c.py:
 
     allChar = string.uppercase + string.lowercase
@@ -15197,9 +14720,9 @@ charToSoundex = string.maketrans(allChar, "91239129922455912623919292" * 2)
 def soundex(source):
     # ...
     digits = source[0].upper() + source[1:].translate(charToSoundex)
-
    What the heck is going on here?  string.maketrans creates a translation matrix between two strings: the first argument and the second argument.  In this case, the first argument
-is the string ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz, and the second argument is the string 9123912992245591262391929291239129922455912623919292.  See the pattern?  It's the same conversion pattern we were setting up longhand with a dictionary.  A maps to 9, B maps
-to 1, C maps to 2, and so forth.  But it's not a dictionary; it's a specialized data structure that you can access using the
+
    What the heck is going on here?  string.maketrans creates a translation matrix between two strings: the first argument and the second argument. In this case, the first argument
+is the string ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz, and the second argument is the string 9123912992245591262391929291239129922455912623919292. See the pattern?  It's the same conversion pattern we were setting up longhand with a dictionary. A maps to 9, B maps
+to 1, C maps to 2, and so forth. But it's not a dictionary; it's a specialized data structure that you can access using the
 string method translate, which translates each character into the corresponding digit, according to the matrix defined by string.maketrans.
 
    timeit shows that soundex2c.py is significantly faster than defining a dictionary and looping through the input and building the output incrementally:
 
    @@ -15207,7 +14730,7 @@ string method translate, which translates each character into the c
 Woo             W000 11.437645008
 Pilgrim         P426 13.2825062962
 Flingjingwaller F452 18.5570110168
-
    You're not going to get much better than that.  Python has a specialized function that does exactly what you want to do; use it and move on.
+
    You're not going to get much better than that. Python has a specialized function that does exactly what you want to do; use it and move on.
 
    Example 18.4. Best Result So Far: soundex/stage2/soundex2c.py
     import string, re
 
@@ -15236,7 +14759,7 @@ if __name__ == '__main__':
         t = Timer(statement, "from __main__ import soundex")
         print name.ljust(15), soundex(name), min(t.repeat())
 
    18.5. Optimizing List Operations
    
-
    The third step in the Soundex algorithm is eliminating consecutive duplicate digits.  What's the best way to do this?
+
    The third step in the Soundex algorithm is eliminating consecutive duplicate digits. What's the best way to do this?
 
    Here's the code we have so far, in soundex/stage2/soundex2c.py:
 
         digits2 = digits[0]
@@ -15249,7 +14772,7 @@ if __name__ == '__main__':
 Woo             W000 12.6070768771
 Pilgrim         P426 14.4033353401
 Flingjingwaller F452 19.7774882003
-
    The first thing to consider is whether it's efficient to check digits[-1] each time through the loop.  Are list indexes expensive?  Would we be better off maintaining the last digit in a separate
+
    The first thing to consider is whether it's efficient to check digits[-1] each time through the loop. Are list indexes expensive?  Would we be better off maintaining the last digit in a separate
 variable, and checking that instead?
 
    To answer this question, here is soundex/stage3/soundex3a.py:
 
    @@ -15265,13 +14788,13 @@ variable, and checking that instead?
 Woo             W000 11.5346048171
 Pilgrim         P426 13.3950636184
 Flingjingwaller F452 18.6108927252
-
    Why isn't soundex3a.py faster?  It turns out that list indexes in Python are extremely efficient.  Repeatedly accessing digits2[-1] is no problem at all.  On the other hand, manually maintaining the last seen digit in a separate variable means we have two variable assignments for each digit we're storing, which wipes out any small gains we might have gotten from eliminating
+
    Why isn't soundex3a.py faster?  It turns out that list indexes in Python are extremely efficient. Repeatedly accessing digits2[-1] is no problem at all. On the other hand, manually maintaining the last seen digit in a separate variable means we have two variable assignments for each digit we're storing, which wipes out any small gains we might have gotten from eliminating
 the list lookup.
-
    Let's try something radically different.  If it's possible to treat a string as a list of characters, it should be possible
-to use a list comprehension to iterate through the list.  The problem is, the code needs access to the previous character
+
    Let's try something radically different. If it's possible to treat a string as a list of characters, it should be possible
+to use a list comprehension to iterate through the list. The problem is, the code needs access to the previous character
 in the list, and that's not easy to do with a straightforward list comprehension.
 
    However, it is possible to create a list of index numbers using the built-in range() function, and use those index numbers to progressively search through the list and pull out each character that is different
-from the previous character.  That will give you a list of characters, and you can use the string method join() to reconstruct a string from that.
+from the previous character. That will give you a list of characters, and you can use the string method join() to reconstruct a string from that.
 
    Here is soundex/stage3/soundex3b.py:
 
         digits2 = "".join([digits[i] for i in range(len(digits))
@@ -15282,7 +14805,7 @@ from the previous character.  That will give you a list of characters, and you c
 Woo             W000 14.2245271396
 Pilgrim         P426 17.8337165757
 Flingjingwaller F452 25.9954005327
-
    It's possible that the techniques so far as have been “string-centric”.  Python can convert a string into a list of characters with a single command: list('abc') returns ['a', 'b', 'c'].  Furthermore, lists can be modified in place very quickly.  Instead of incrementally building a new list (or string) out of the source string, why not move elements around
+
    It's possible that the techniques so far as have been “string-centric”. Python can convert a string into a list of characters with a single command: list('abc') returns ['a', 'b', 'c']. Furthermore, lists can be modified in place very quickly. Instead of incrementally building a new list (or string) out of the source string, why not move elements around
 within a single list?
 
    Here is soundex/stage3/soundex3c.py, which modifies a list in place to remove consecutive duplicate elements:
 
    @@ -15300,7 +14823,7 @@ within a single list?
 Woo             W000 14.1662554878
 Pilgrim         P426 16.0397885765
 Flingjingwaller F452 22.1789341942
-
    We haven't made any progress here at all, except to try and rule out several “clever” techniques.  The fastest code we've seen so far was the original, most straightforward method (soundex2c.py).  Sometimes it doesn't pay to be clever.
+
    We haven't made any progress here at all, except to try and rule out several “clever” techniques. The fastest code we've seen so far was the original, most straightforward method (soundex2c.py). Sometimes it doesn't pay to be clever.
 
    Example 18.5. Best Result So Far: soundex/stage2/soundex2c.py
     import string, re
 
@@ -15329,7 +14852,7 @@ if __name__ == '__main__':
         t = Timer(statement, "from __main__ import soundex")
         print name.ljust(15), soundex(name), min(t.repeat())
 
    18.6. Optimizing String Manipulation
    
-
    The final step of the Soundex algorithm is padding short results with zeros, and truncating long results.  What is the best
+
    The final step of the Soundex algorithm is padding short results with zeros, and truncating long results. What is the best
    way to do this?
 
    This is what we have so far, taken from soundex/stage2/soundex2c.py:
 
    @@ -15343,7 +14866,7 @@ if __name__ == '__main__':
 Woo             W000 12.6070768771
 Pilgrim         P426 14.4033353401
 Flingjingwaller F452 19.7774882003
-
    The first thing to consider is replacing that regular expression with a loop.  This code is from soundex/stage4/soundex4a.py:
+
    The first thing to consider is replacing that regular expression with a loop. This code is from soundex/stage4/soundex4a.py:
 
         digits3 = ''
     for d in digits2:
@@ -15355,25 +14878,25 @@ Flingjingwaller F452 19.7774882003
 Woo             W000 6.62865531792
 Pilgrim         P426 9.02247576158
 Flingjingwaller F452 13.6328416042
-
    But wait a minute.  A loop to remove characters from a string?  We can use a simple string method for that.  Here's soundex/stage4/soundex4b.py:
+
    But wait a minute. A loop to remove characters from a string?  We can use a simple string method for that. Here's soundex/stage4/soundex4b.py:
 
         digits3 = digits2.replace('9', '')
-
    Is soundex4b.py faster?  That's an interesting question.  It depends on the input:
+
    Is soundex4b.py faster?  That's an interesting question. It depends on the input:
 
     C:\samples\soundex\stage4>python soundex4b.py
 Woo             W000 6.75477414029
 Pilgrim         P426 7.56652144337
 Flingjingwaller F452 10.8727729362
-
    The string method in soundex4b.py is faster than the loop for most names, but it's actually slightly slower than soundex4a.py in the trivial case (of a very short name).  Performance optimizations aren't always uniform; tuning that makes one case
-faster can sometimes make other cases slower.  In this case, the majority of cases will benefit from the change, so let's
+
    The string method in soundex4b.py is faster than the loop for most names, but it's actually slightly slower than soundex4a.py in the trivial case (of a very short name). Performance optimizations aren't always uniform; tuning that makes one case
+faster can sometimes make other cases slower. In this case, the majority of cases will benefit from the change, so let's
 leave it at that, but the principle is an important one to remember.
 
    Last but not least, let's examine the final two steps of the algorithm: padding short results with zeros, and truncating long
-results to four characters.  The code you see in soundex4b.py does just that, but it's horribly inefficient.  Take a look at soundex/stage4/soundex4c.py to see why:
+results to four characters. The code you see in soundex4b.py does just that, but it's horribly inefficient. Take a look at soundex/stage4/soundex4c.py to see why:
 
         digits3 += '000'
     return digits3[:4]
 
    Why do we need a while loop to pad out the result?  We know in advance that we're going to truncate the result to four characters, and we know that
-we already have at least one character (the initial letter, which is passed unchanged from the original source variable).  That means we can simply add three zeros to the output, then truncate it.  Don't get stuck in a rut over the
+we already have at least one character (the initial letter, which is passed unchanged from the original source variable). That means we can simply add three zeros to the output, then truncate it. Don't get stuck in a rut over the
 exact wording of the problem; looking at the problem slightly differently can lead to a simpler solution.
 
    How much speed do we gain in soundex4c.py by dropping the while loop?  It's significant:
 
    @@ -15382,7 +14905,7 @@ exact wording of the problem; looking at the problem slightly differently can le
 Pilgrim         P426 7.30642134685
 Flingjingwaller F452 10.689832367
 
    Finally, there is still one more thing you can do to these three lines of code to make them faster: you can combine them into
-one line.  Take a look at soundex/stage4/soundex4d.py:
+one line. Take a look at soundex/stage4/soundex4d.py:
 
         return (digits2.replace('9', '') + '000')[:4]
 
    Putting all this code on one line in soundex4d.py is barely faster than soundex4c.py:
@@ -15391,28 +14914,28 @@ one line.  Take a look at soundex/stage4/soundex4d.py:
 Woo             W000 4.93624105857
 Pilgrim         P426 7.19747593619
 Flingjingwaller F452 10.5490700634
-
    It is also significantly less readable, and for not much performance gain.  Is that worth it?  I hope you have good comments.
-Performance isn't everything.  Your optimization efforts must always be balanced against threats to your program's readability
+
    It is also significantly less readable, and for not much performance gain. Is that worth it?  I hope you have good comments.
+Performance isn't everything. Your optimization efforts must always be balanced against threats to your program's readability
 and maintainability.
 
    18.7. Summary
    
 
    This chapter has illustrated several important aspects of performance tuning in Python, and performance tuning in general.
 
    
 
      
-
    • If you need to choose between regular expressions and writing a loop, choose regular expressions.  The regular expression
+
    • If you need to choose between regular expressions and writing a loop, choose regular expressions. The regular expression
       engine is compiled in C and runs natively on your computer; your loop is written in Python and runs through the Python interpreter.
 
-
    • If you need to choose between regular expressions and string methods, choose string methods.  Both are compiled in C, so choose
+
    • If you need to choose between regular expressions and string methods, choose string methods. Both are compiled in C, so choose
       the simpler one.
 
-
    • General-purpose dictionary lookups are fast, but specialtiy functions such as string.maketrans and string methods such as isalpha() are faster.  If Python has a custom-tailored function for you, use it.
+
    • General-purpose dictionary lookups are fast, but specialtiy functions such as string.maketrans and string methods such as isalpha() are faster. If Python has a custom-tailored function for you, use it.
 
-
    • Don't be too clever.  Sometimes the most obvious algorithm is also the fastest.
-
    • Don't sweat it too much.  Performance isn't everything.
+
    • Don't be too clever. Sometimes the most obvious algorithm is also the fastest.
+
    • Don't sweat it too much. Performance isn't everything.
 
    
-
    I can't emphasize that last point strongly enough.  Over the course of this chapter, you made this function three times faster
-and saved 20 seconds over 1 million function calls.  Great.  Now think: over the course of those million function calls, how
+
    I can't emphasize that last point strongly enough. Over the course of this chapter, you made this function three times faster
+and saved 20 seconds over 1 million function calls. Great. Now think: over the course of those million function calls, how
 many seconds will your surrounding application wait for a database connection?  Or wait for disk I/O?  Or wait for user input?
-Don't spend too much time over-optimizing one algorithm, or you'll ignore obvious improvements somewhere else.  Develop an
+Don't spend too much time over-optimizing one algorithm, or you'll ignore obvious improvements somewhere else. Develop an
 instinct for the sort of code that Python runs well, correct obvious blunders if you find them, and leave the rest alone.
 
 
diff --git a/dip3.js b/dip3.js
index 2b79413..0c0d597 100644
--- a/dip3.js
+++ b/dip3.js
@@ -1,11 +1,10 @@
 /*
 var LANGS = {'python2': 'Python 2', 'java': 'Java', 'perl5': 'Perl 5', 'clang': 'C'};
 */
-var HIDESHOW = {'visible': 'hide', 'hidden': 'show'};
-
-google.load("jquery", "1.3");
-google.setOnLoadCallback(function() {
+//google.load("jquery", "1.3");
+//google.setOnLoadCallback(function() {
 $(document).ready(function() {
+  var HS = {'visible': 'hide', 'hidden': 'show'};
 /*
   // toggle-able language comparisons
   for (var lang in LANGS) {
@@ -26,7 +25,7 @@ $(document).ready(function() {
   $("pre.code, pre.screen").each(function(i) {
     this.id = "autopre" + i;
     $(this).wrapInner('
    ');
-    $(this).prepend('
    [' + HIDESHOW['visible'] + '] [open in new window]
    ');
+    $(this).prepend('
    [' + HS['visible'] + '] [open in new window]
    ');
 
     $(this).prev("p.download").each(function(i) {
       $(this).next("pre").find("div.widgets").append(" " + $(this).html());
@@ -57,7 +56,7 @@ $(document).ready(function() {
   });
 
 }); /* document.ready */
-}); /* google.setOnLoadCallback */
+//}); /* google.setOnLoadCallback */
 
 /*
 function toggleComparisonNotes(lang) {
@@ -70,7 +69,7 @@ function toggleComparisonNotes(lang) {
 function toggleCodeBlock(id) {
   $("#" + id).find("div.block").toggle();
   var a = $("#" + id).find("a.toggle");
-  a.text(a.text() == HIDESHOW['visible'] ? HIDESHOW['hidden'] : HIDESHOW['visible']);
+  a.text(a.text() == HS['visible'] ? HS['hidden'] : HS['visible']);
 }
 
 function plainTextOnClick(id) {
diff --git a/index.html b/index.html
index 72c4037..3eb9394 100644
--- a/index.html
+++ b/index.html
@@ -1,38 +1,35 @@
 
-
+
 
-
+
 Dive Into Python 3
-
-
-
-
 
-
-
-
    Dive Into Python 3 will cover Python 3 and its differences from Python 2.  Compared to the original Dive Into Python, it will be about 50% revised and 50% new material.  I will publish drafts online as I go.  The final version will be published on paper by Apress.  The book will remain online under the CC-BY-SA-3.0 license.
+
    
+
    Dive Into Python 3 will cover Python 3 and its differences from Python 2. Compared to the original Dive Into Python, it will be about 50% revised and 50% new material. I will publish drafts online as I go. The final version will be published on paper by Apress. The book will remain online under the CC-BY-SA-3.0 license.
 
    Here’s what I’ve written so far:
    
 
-
    There is a changelog, a feed, and discussion on Reddit.  During development, you can download the book by cloning the Mercurial repository:
-
    you@localhost:~$ hg clone http://hg.diveintopython3.org/ diveintopython3
    
+
    There is a changelog, a feed, and discussion on Reddit. During development, you can download the book by cloning the Mercurial repository:
+
    you@localhost:~$ hg clone http://hg.diveintopython3.org/ diveintopython3
    
 
    The final version will be downloadable as HTML and PDF.
-
    This site is optimized for Lynx just because fuck you.
    I’m told it also looks good in graphical browsers.
-
    © 2001-4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
+
    This site is optimized for Lynx just because fuck you.
    I’m told it also looks good in graphical browsers.
+
    © 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
 
-
-
diff --git a/jquery.js b/jquery.js
new file mode 100644
index 0000000..96095bc
--- /dev/null
+++ b/jquery.js
@@ -0,0 +1,4241 @@
+/*!
+ * jQuery JavaScript Library v1.3.1
+ * http://jquery.com/
+ *
+ * Copyright (c) 2009 John Resig
+ * Dual licensed under the MIT and GPL licenses.
+ * http://docs.jquery.com/License
+ *
+ * Date: 2009-01-21 20:42:16 -0500 (Wed, 21 Jan 2009)
+ * Revision: 6158
+ */
+(function(){
+
+var 
+	// Will speed up references to window, and allows munging its name.
+	window = this,
+	// Will speed up references to undefined, and allows munging its name.
+	undefined,
+	// Map over jQuery in case of overwrite
+	_jQuery = window.jQuery,
+	// Map over the $ in case of overwrite
+	_$ = window.$,
+
+	jQuery = window.jQuery = window.$ = function( selector, context ) {
+		// The jQuery object is actually just the init constructor 'enhanced'
+		return new jQuery.fn.init( selector, context );
+	},
+
+	// A simple way to check for HTML strings or ID strings
+	// (both of which we optimize for)
+	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
+	// Is it a simple selector
+	isSimple = /^.[^:#\[\.,]*$/;
+
+jQuery.fn = jQuery.prototype = {
+	init: function( selector, context ) {
+		// Make sure that a selection was provided
+		selector = selector || document;
+
+		// Handle $(DOMElement)
+		if ( selector.nodeType ) {
+			this[0] = selector;
+			this.length = 1;
+			this.context = selector;
+			return this;
+		}
+		// Handle HTML strings
+		if ( typeof selector === "string" ) {
+			// Are we dealing with HTML string or an ID?
+			var match = quickExpr.exec( selector );
+
+			// Verify a match, and that no context was specified for #id
+			if ( match && (match[1] || !context) ) {
+
+				// HANDLE: $(html) -> $(array)
+				if ( match[1] )
+					selector = jQuery.clean( [ match[1] ], context );
+
+				// HANDLE: $("#id")
+				else {
+					var elem = document.getElementById( match[3] );
+
+					// Handle the case where IE and Opera return items
+					// by name instead of ID
+					if ( elem && elem.id != match[3] )
+						return jQuery().find( selector );
+
+					// Otherwise, we inject the element directly into the jQuery object
+					var ret = jQuery( elem || [] );
+					ret.context = document;
+					ret.selector = selector;
+					return ret;
+				}
+
+			// HANDLE: $(expr, [context])
+			// (which is just equivalent to: $(content).find(expr)
+			} else
+				return jQuery( context ).find( selector );
+
+		// HANDLE: $(function)
+		// Shortcut for document ready
+		} else if ( jQuery.isFunction( selector ) )
+			return jQuery( document ).ready( selector );
+
+		// Make sure that old selector state is passed along
+		if ( selector.selector && selector.context ) {
+			this.selector = selector.selector;
+			this.context = selector.context;
+		}
+
+		return this.setArray(jQuery.makeArray(selector));
+	},
+
+	// Start with an empty selector
+	selector: "",
+
+	// The current version of jQuery being used
+	jquery: "1.3.1",
+
+	// The number of elements contained in the matched element set
+	size: function() {
+		return this.length;
+	},
+
+	// Get the Nth element in the matched element set OR
+	// Get the whole matched element set as a clean array
+	get: function( num ) {
+		return num === undefined ?
+
+			// Return a 'clean' array
+			jQuery.makeArray( this ) :
+
+			// Return just the object
+			this[ num ];
+	},
+
+	// Take an array of elements and push it onto the stack
+	// (returning the new matched element set)
+	pushStack: function( elems, name, selector ) {
+		// Build a new jQuery matched element set
+		var ret = jQuery( elems );
+
+		// Add the old object onto the stack (as a reference)
+		ret.prevObject = this;
+
+		ret.context = this.context;
+
+		if ( name === "find" )
+			ret.selector = this.selector + (this.selector ? " " : "") + selector;
+		else if ( name )
+			ret.selector = this.selector + "." + name + "(" + selector + ")";
+
+		// Return the newly-formed element set
+		return ret;
+	},
+
+	// Force the current matched set of elements to become
+	// the specified array of elements (destroying the stack in the process)
+	// You should use pushStack() in order to do this, but maintain the stack
+	setArray: function( elems ) {
+		// Resetting the length to 0, then using the native Array push
+		// is a super-fast way to populate an object with array-like properties
+		this.length = 0;
+		Array.prototype.push.apply( this, elems );
+
+		return this;
+	},
+
+	// Execute a callback for every element in the matched set.
+	// (You can seed the arguments with an array of args, but this is
+	// only used internally.)
+	each: function( callback, args ) {
+		return jQuery.each( this, callback, args );
+	},
+
+	// Determine the position of an element within
+	// the matched set of elements
+	index: function( elem ) {
+		// Locate the position of the desired element
+		return jQuery.inArray(
+			// If it receives a jQuery object, the first element is used
+			elem && elem.jquery ? elem[0] : elem
+		, this );
+	},
+
+	attr: function( name, value, type ) {
+		var options = name;
+
+		// Look for the case where we're accessing a style value
+		if ( typeof name === "string" )
+			if ( value === undefined )
+				return this[0] && jQuery[ type || "attr" ]( this[0], name );
+
+			else {
+				options = {};
+				options[ name ] = value;
+			}
+
+		// Check to see if we're setting style values
+		return this.each(function(i){
+			// Set all the styles
+			for ( name in options )
+				jQuery.attr(
+					type ?
+						this.style :
+						this,
+					name, jQuery.prop( this, options[ name ], type, i, name )
+				);
+		});
+	},
+
+	css: function( key, value ) {
+		// ignore negative width and height values
+		if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
+			value = undefined;
+		return this.attr( key, value, "curCSS" );
+	},
+
+	text: function( text ) {
+		if ( typeof text !== "object" && text != null )
+			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
+
+		var ret = "";
+
+		jQuery.each( text || this, function(){
+			jQuery.each( this.childNodes, function(){
+				if ( this.nodeType != 8 )
+					ret += this.nodeType != 1 ?
+						this.nodeValue :
+						jQuery.fn.text( [ this ] );
+			});
+		});
+
+		return ret;
+	},
+
+	wrapAll: function( html ) {
+		if ( this[0] ) {
+			// The elements to wrap the target around
+			var wrap = jQuery( html, this[0].ownerDocument ).clone();
+
+			if ( this[0].parentNode )
+				wrap.insertBefore( this[0] );
+
+			wrap.map(function(){
+				var elem = this;
+
+				while ( elem.firstChild )
+					elem = elem.firstChild;
+
+				return elem;
+			}).append(this);
+		}
+
+		return this;
+	},
+
+	wrapInner: function( html ) {
+		return this.each(function(){
+			jQuery( this ).contents().wrapAll( html );
+		});
+	},
+
+	wrap: function( html ) {
+		return this.each(function(){
+			jQuery( this ).wrapAll( html );
+		});
+	},
+
+	append: function() {
+		return this.domManip(arguments, true, function(elem){
+			if (this.nodeType == 1)
+				this.appendChild( elem );
+		});
+	},
+
+	prepend: function() {
+		return this.domManip(arguments, true, function(elem){
+			if (this.nodeType == 1)
+				this.insertBefore( elem, this.firstChild );
+		});
+	},
+
+	before: function() {
+		return this.domManip(arguments, false, function(elem){
+			this.parentNode.insertBefore( elem, this );
+		});
+	},
+
+	after: function() {
+		return this.domManip(arguments, false, function(elem){
+			this.parentNode.insertBefore( elem, this.nextSibling );
+		});
+	},
+
+	end: function() {
+		return this.prevObject || jQuery( [] );
+	},
+
+	// For internal use only.
+	// Behaves like an Array's .push method, not like a jQuery method.
+	push: [].push,
+
+	find: function( selector ) {
+		if ( this.length === 1 && !/,/.test(selector) ) {
+			var ret = this.pushStack( [], "find", selector );
+			ret.length = 0;
+			jQuery.find( selector, this[0], ret );
+			return ret;
+		} else {
+			var elems = jQuery.map(this, function(elem){
+				return jQuery.find( selector, elem );
+			});
+
+			return this.pushStack( /[^+>] [^+>]/.test( selector ) ?
+				jQuery.unique( elems ) :
+				elems, "find", selector );
+		}
+	},
+
+	clone: function( events ) {
+		// Do the clone
+		var ret = this.map(function(){
+			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
+				// IE copies events bound via attachEvent when
+				// using cloneNode. Calling detachEvent on the
+				// clone will also remove the events from the orignal
+				// In order to get around this, we use innerHTML.
+				// Unfortunately, this means some modifications to
+				// attributes in IE that are actually only stored
+				// as properties will not be copied (such as the
+				// the name attribute on an input).
+				var clone = this.cloneNode(true),
+					container = document.createElement("div");
+				container.appendChild(clone);
+				return jQuery.clean([container.innerHTML])[0];
+			} else
+				return this.cloneNode(true);
+		});
+
+		// Need to set the expando to null on the cloned set if it exists
+		// removeData doesn't work here, IE removes it from the original as well
+		// this is primarily for IE but the data expando shouldn't be copied over in any browser
+		var clone = ret.find("*").andSelf().each(function(){
+			if ( this[ expando ] !== undefined )
+				this[ expando ] = null;
+		});
+
+		// Copy the events from the original to the clone
+		if ( events === true )
+			this.find("*").andSelf().each(function(i){
+				if (this.nodeType == 3)
+					return;
+				var events = jQuery.data( this, "events" );
+
+				for ( var type in events )
+					for ( var handler in events[ type ] )
+						jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
+			});
+
+		// Return the cloned set
+		return ret;
+	},
+
+	filter: function( selector ) {
+		return this.pushStack(
+			jQuery.isFunction( selector ) &&
+			jQuery.grep(this, function(elem, i){
+				return selector.call( elem, i );
+			}) ||
+
+			jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
+				return elem.nodeType === 1;
+			}) ), "filter", selector );
+	},
+
+	closest: function( selector ) {
+		var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null;
+
+		return this.map(function(){
+			var cur = this;
+			while ( cur && cur.ownerDocument ) {
+				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) )
+					return cur;
+				cur = cur.parentNode;
+			}
+		});
+	},
+
+	not: function( selector ) {
+		if ( typeof selector === "string" )
+			// test special case where just one selector is passed in
+			if ( isSimple.test( selector ) )
+				return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
+			else
+				selector = jQuery.multiFilter( selector, this );
+
+		var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
+		return this.filter(function() {
+			return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
+		});
+	},
+
+	add: function( selector ) {
+		return this.pushStack( jQuery.unique( jQuery.merge(
+			this.get(),
+			typeof selector === "string" ?
+				jQuery( selector ) :
+				jQuery.makeArray( selector )
+		)));
+	},
+
+	is: function( selector ) {
+		return !!selector && jQuery.multiFilter( selector, this ).length > 0;
+	},
+
+	hasClass: function( selector ) {
+		return !!selector && this.is( "." + selector );
+	},
+
+	val: function( value ) {
+		if ( value === undefined ) {			
+			var elem = this[0];
+
+			if ( elem ) {
+				if( jQuery.nodeName( elem, 'option' ) )
+					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
+				
+				// We need to handle select boxes special
+				if ( jQuery.nodeName( elem, "select" ) ) {
+					var index = elem.selectedIndex,
+						values = [],
+						options = elem.options,
+						one = elem.type == "select-one";
+
+					// Nothing was selected
+					if ( index < 0 )
+						return null;
+
+					// Loop through all the selected options
+					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
+						var option = options[ i ];
+
+						if ( option.selected ) {
+							// Get the specifc value for the option
+							value = jQuery(option).val();
+
+							// We don't need an array for one selects
+							if ( one )
+								return value;
+
+							// Multi-Selects return an array
+							values.push( value );
+						}
+					}
+
+					return values;				
+				}
+
+				// Everything else, we just grab the value
+				return (elem.value || "").replace(/\r/g, "");
+
+			}
+
+			return undefined;
+		}
+
+		if ( typeof value === "number" )
+			value += '';
+
+		return this.each(function(){
+			if ( this.nodeType != 1 )
+				return;
+
+			if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
+				this.checked = (jQuery.inArray(this.value, value) >= 0 ||
+					jQuery.inArray(this.name, value) >= 0);
+
+			else if ( jQuery.nodeName( this, "select" ) ) {
+				var values = jQuery.makeArray(value);
+
+				jQuery( "option", this ).each(function(){
+					this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
+						jQuery.inArray( this.text, values ) >= 0);
+				});
+
+				if ( !values.length )
+					this.selectedIndex = -1;
+
+			} else
+				this.value = value;
+		});
+	},
+
+	html: function( value ) {
+		return value === undefined ?
+			(this[0] ?
+				this[0].innerHTML :
+				null) :
+			this.empty().append( value );
+	},
+
+	replaceWith: function( value ) {
+		return this.after( value ).remove();
+	},
+
+	eq: function( i ) {
+		return this.slice( i, +i + 1 );
+	},
+
+	slice: function() {
+		return this.pushStack( Array.prototype.slice.apply( this, arguments ),
+			"slice", Array.prototype.slice.call(arguments).join(",") );
+	},
+
+	map: function( callback ) {
+		return this.pushStack( jQuery.map(this, function(elem, i){
+			return callback.call( elem, i, elem );
+		}));
+	},
+
+	andSelf: function() {
+		return this.add( this.prevObject );
+	},
+
+	domManip: function( args, table, callback ) {
+		if ( this[0] ) {
+			var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
+				scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
+				first = fragment.firstChild,
+				extra = this.length > 1 ? fragment.cloneNode(true) : fragment;
+
+			if ( first )
+				for ( var i = 0, l = this.length; i < l; i++ )
+					callback.call( root(this[i], first), i > 0 ? extra.cloneNode(true) : fragment );
+			
+			if ( scripts )
+				jQuery.each( scripts, evalScript );
+		}
+
+		return this;
+		
+		function root( elem, cur ) {
+			return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
+				(elem.getElementsByTagName("tbody")[0] ||
+				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
+				elem;
+		}
+	}
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+function evalScript( i, elem ) {
+	if ( elem.src )
+		jQuery.ajax({
+			url: elem.src,
+			async: false,
+			dataType: "script"
+		});
+
+	else
+		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
+
+	if ( elem.parentNode )
+		elem.parentNode.removeChild( elem );
+}
+
+function now(){
+	return +new Date;
+}
+
+jQuery.extend = jQuery.fn.extend = function() {
+	// copy reference to target object
+	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
+
+	// Handle a deep copy situation
+	if ( typeof target === "boolean" ) {
+		deep = target;
+		target = arguments[1] || {};
+		// skip the boolean and the target
+		i = 2;
+	}
+
+	// Handle case when target is a string or something (possible in deep copy)
+	if ( typeof target !== "object" && !jQuery.isFunction(target) )
+		target = {};
+
+	// extend jQuery itself if only one argument is passed
+	if ( length == i ) {
+		target = this;
+		--i;
+	}
+
+	for ( ; i < length; i++ )
+		// Only deal with non-null/undefined values
+		if ( (options = arguments[ i ]) != null )
+			// Extend the base object
+			for ( var name in options ) {
+				var src = target[ name ], copy = options[ name ];
+
+				// Prevent never-ending loop
+				if ( target === copy )
+					continue;
+
+				// Recurse if we're merging object values
+				if ( deep && copy && typeof copy === "object" && !copy.nodeType )
+					target[ name ] = jQuery.extend( deep, 
+						// Never move original objects, clone them
+						src || ( copy.length != null ? [ ] : { } )
+					, copy );
+
+				// Don't bring in undefined values
+				else if ( copy !== undefined )
+					target[ name ] = copy;
+
+			}
+
+	// Return the modified object
+	return target;
+};
+
+// exclude the following css properties to add px
+var	exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
+	// cache defaultView
+	defaultView = document.defaultView || {},
+	toString = Object.prototype.toString;
+
+jQuery.extend({
+	noConflict: function( deep ) {
+		window.$ = _$;
+
+		if ( deep )
+			window.jQuery = _jQuery;
+
+		return jQuery;
+	},
+
+	// See test/unit/core.js for details concerning isFunction.
+	// Since version 1.3, DOM methods and functions like alert
+	// aren't supported. They return false on IE (#2968).
+	isFunction: function( obj ) {
+		return toString.call(obj) === "[object Function]";
+	},
+
+	isArray: function( obj ) {
+		return toString.call(obj) === "[object Array]";
+	},
+
+	// check if an element is in a (or is an) XML document
+	isXMLDoc: function( elem ) {
+		return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
+			!!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
+	},
+
+	// Evalulates a script in a global context
+	globalEval: function( data ) {
+		data = jQuery.trim( data );
+
+		if ( data ) {
+			// Inspired by code by Andrea Giammarchi
+			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
+			var head = document.getElementsByTagName("head")[0] || document.documentElement,
+				script = document.createElement("script");
+
+			script.type = "text/javascript";
+			if ( jQuery.support.scriptEval )
+				script.appendChild( document.createTextNode( data ) );
+			else
+				script.text = data;
+
+			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
+			// This arises when a base node is used (#2709).
+			head.insertBefore( script, head.firstChild );
+			head.removeChild( script );
+		}
+	},
+
+	nodeName: function( elem, name ) {
+		return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
+	},
+
+	// args is for internal usage only
+	each: function( object, callback, args ) {
+		var name, i = 0, length = object.length;
+
+		if ( args ) {
+			if ( length === undefined ) {
+				for ( name in object )
+					if ( callback.apply( object[ name ], args ) === false )
+						break;
+			} else
+				for ( ; i < length; )
+					if ( callback.apply( object[ i++ ], args ) === false )
+						break;
+
+		// A special, fast, case for the most common use of each
+		} else {
+			if ( length === undefined ) {
+				for ( name in object )
+					if ( callback.call( object[ name ], name, object[ name ] ) === false )
+						break;
+			} else
+				for ( var value = object[0];
+					i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
+		}
+
+		return object;
+	},
+
+	prop: function( elem, value, type, i, name ) {
+		// Handle executable functions
+		if ( jQuery.isFunction( value ) )
+			value = value.call( elem, i );
+
+		// Handle passing in a number to a CSS property
+		return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
+			value + "px" :
+			value;
+	},
+
+	className: {
+		// internal only, use addClass("class")
+		add: function( elem, classNames ) {
+			jQuery.each((classNames || "").split(/\s+/), function(i, className){
+				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
+					elem.className += (elem.className ? " " : "") + className;
+			});
+		},
+
+		// internal only, use removeClass("class")
+		remove: function( elem, classNames ) {
+			if (elem.nodeType == 1)
+				elem.className = classNames !== undefined ?
+					jQuery.grep(elem.className.split(/\s+/), function(className){
+						return !jQuery.className.has( classNames, className );
+					}).join(" ") :
+					"";
+		},
+
+		// internal only, use hasClass("class")
+		has: function( elem, className ) {
+			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
+		}
+	},
+
+	// A method for quickly swapping in/out CSS properties to get correct calculations
+	swap: function( elem, options, callback ) {
+		var old = {};
+		// Remember the old values, and insert the new ones
+		for ( var name in options ) {
+			old[ name ] = elem.style[ name ];
+			elem.style[ name ] = options[ name ];
+		}
+
+		callback.call( elem );
+
+		// Revert the old values
+		for ( var name in options )
+			elem.style[ name ] = old[ name ];
+	},
+
+	css: function( elem, name, force ) {
+		if ( name == "width" || name == "height" ) {
+			var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
+
+			function getWH() {
+				val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
+				var padding = 0, border = 0;
+				jQuery.each( which, function() {
+					padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
+					border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
+				});
+				val -= Math.round(padding + border);
+			}
+
+			if ( jQuery(elem).is(":visible") )
+				getWH();
+			else
+				jQuery.swap( elem, props, getWH );
+
+			return Math.max(0, val);
+		}
+
+		return jQuery.curCSS( elem, name, force );
+	},
+
+	curCSS: function( elem, name, force ) {
+		var ret, style = elem.style;
+
+		// We need to handle opacity special in IE
+		if ( name == "opacity" && !jQuery.support.opacity ) {
+			ret = jQuery.attr( style, "opacity" );
+
+			return ret == "" ?
+				"1" :
+				ret;
+		}
+
+		// Make sure we're using the right name for getting the float value
+		if ( name.match( /float/i ) )
+			name = styleFloat;
+
+		if ( !force && style && style[ name ] )
+			ret = style[ name ];
+
+		else if ( defaultView.getComputedStyle ) {
+
+			// Only "float" is needed here
+			if ( name.match( /float/i ) )
+				name = "float";
+
+			name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
+
+			var computedStyle = defaultView.getComputedStyle( elem, null );
+
+			if ( computedStyle )
+				ret = computedStyle.getPropertyValue( name );
+
+			// We should always get a number back from opacity
+			if ( name == "opacity" && ret == "" )
+				ret = "1";
+
+		} else if ( elem.currentStyle ) {
+			var camelCase = name.replace(/\-(\w)/g, function(all, letter){
+				return letter.toUpperCase();
+			});
+
+			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
+
+			// From the awesome hack by Dean Edwards
+			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
+
+			// If we're not dealing with a regular pixel number
+			// but a number that has a weird ending, we need to convert it to pixels
+			if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
+				// Remember the original values
+				var left = style.left, rsLeft = elem.runtimeStyle.left;
+
+				// Put in the new values to get a computed value out
+				elem.runtimeStyle.left = elem.currentStyle.left;
+				style.left = ret || 0;
+				ret = style.pixelLeft + "px";
+
+				// Revert the changed values
+				style.left = left;
+				elem.runtimeStyle.left = rsLeft;
+			}
+		}
+
+		return ret;
+	},
+
+	clean: function( elems, context, fragment ) {
+		context = context || document;
+
+		// !context.createElement fails in IE with an error but returns typeof 'object'
+		if ( typeof context.createElement === "undefined" )
+			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
+
+		// If a single string is passed in and it's a single tag
+		// just do a createElement and skip the rest
+		if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
+			var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
+			if ( match )
+				return [ context.createElement( match[1] ) ];
+		}
+
+		var ret = [], scripts = [], div = context.createElement("div");
+
+		jQuery.each(elems, function(i, elem){
+			if ( typeof elem === "number" )
+				elem += '';
+
+			if ( !elem )
+				return;
+
+			// Convert html string into DOM nodes
+			if ( typeof elem === "string" ) {
+				// Fix "XHTML"-style tags in all browsers
+				elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
+					return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
+						all :
+						front + ">";
+				});
+
+				// Trim whitespace, otherwise indexOf won't work as expected
+				var tags = jQuery.trim( elem ).toLowerCase();
+
+				var wrap =
+					// option or optgroup
+					!tags.indexOf("", "" ] ||
+
+					!tags.indexOf("", "" ] ||
+
+					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
+					[ 1, "", "
    " ] ||
+
+					!tags.indexOf("", "" ] ||
+
+				 	//  matched above
+					(!tags.indexOf("", "" ] ||
+
+					!tags.indexOf("", "" ] ||
+
+					// IE can't serialize  and 
-
-
-
+
    © 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
+
+
diff --git a/porting-code-to-python-3-with-2to3.html b/porting-code-to-python-3-with-2to3.html
index e13c429..b8fbf65 100644
--- a/porting-code-to-python-3-with-2to3.html
+++ b/porting-code-to-python-3-with-2to3.html
@@ -1,93 +1,92 @@
 
-
+
 
-
+
 Porting code to Python 3 with 2to3 - Dive into Python 3
-
-
-
-
 
-
-
    skip to main content
-
    
-
    You are here: Home ‣ Dive Into Python 3 ‣
+
    skip to main content
+
    
+
    You are here: Home ‣ Dive Into Python 3 ‣
 
    Porting code to Python 3 with 2to3
    
-
    
+
    
 
    ❝ Life is pleasant. Death is peaceful. It’s the transition that’s troublesome. ❞
    — Isaac Asimov (attributed)
 
    
 
      
-
    1. Diving in
-
    2. print statement
-
    3. Unicode string literals
-
    4. unicode() global function
-
    5. long data type
-
    6. <> comparison
-
    7. has_key() dictionary method
-
    8. Dictionary methods that return lists
-
    9. Modules that have been renamed or reorganized
+
    10. Diving in
+
    11. print statement
+
    12. Unicode string literals
+
    13. unicode() global function
+
    14. long data type
+
    15. <> comparison
+
    16. has_key() dictionary method
+
    17. Dictionary methods that return lists
+
    18. Modules that have been renamed or reorganized
 
        
-
      1. http
-
      2. urllib
-
      3. dbm
-
      4. xmlrpc
-
      5. Other modules
+
      6. http
+
      7. urllib
+
      8. dbm
+
      9. xmlrpc
+
      10. Other modules
 
      
-
    19. Relative imports within a package
-
    20. next() iterator method
-
    21. filter() global function
-
    22. map() global function
-
    23. reduce() global function (3.1+)
-
    24. apply() global function
-
    25. intern() global function
-
    26. exec statement
-
    27. execfile statement (3.1+)
-
    28. repr literals (backticks)
-
    29. try...except statement
-
    30. raise statement
-
    31. throw method on generators
-
    32. xrange() global function
-
    33. raw_input() and input() global functions
-
    34. func_* function attributes
-
    35. xreadlines() I/O method
-
    36. lambda functions with multiple parameters
-
    37. Special method attributes
-
    38. __nonzero__ special class attribute
-
    39. Octal literals
-
    40. sys.maxint
-
    41. callable() global function
-
    42. zip() global function
-
    43. StandardError() exception
-
    44. types module constants
-
    45. isinstance() global function (3.1+)
-
    46. basestring datatype
-
    47. itertools module
-
    48. sys.exc_type, sys.exc_value, sys.exc_traceback
-
    49. List comprehensions over tuples
-
    50. os.getcwdu() function
-
    51. Metaclasses
-
    52. Matters of style
+
    53. Relative imports within a package
+
    54. next() iterator method
+
    55. filter() global function
+
    56. map() global function
+
    57. reduce() global function (3.1+)
+
    58. apply() global function
+
    59. intern() global function
+
    60. exec statement
+
    61. execfile statement (3.1+)
+
    62. repr literals (backticks)
+
    63. try...except statement
+
    64. raise statement
+
    65. throw method on generators
+
    66. xrange() global function
+
    67. raw_input() and input() global functions
+
    68. func_* function attributes
+
    69. xreadlines() I/O method
+
    70. lambda functions with multiple parameters
+
    71. Special method attributes
+
    72. __nonzero__ special class attribute
+
    73. Octal literals
+
    74. sys.maxint
+
    75. callable() global function
+
    76. zip() global function
+
    77. StandardError() exception
+
    78. types module constants
+
    79. isinstance() global function (3.1+)
+
    80. basestring datatype
+
    81. itertools module
+
    82. sys.exc_type, sys.exc_value, sys.exc_traceback
+
    83. List comprehensions over tuples
+
    84. os.getcwdu() function
+
    85. Metaclasses
+
    86. Matters of style
 
        
-
      1. set() literals
-
      2. buffer() global function
-
      3. Whitespace around commas
-
      4. Common idioms
+
      5. set() literals
+
      6. buffer() global function
+
      7. Whitespace around commas
+
      8. Common idioms
 
      
 
    
-
    Diving in
    
-
    Python 3 comes with a utility script called 2to3, which takes your actual Python 2 source code as input and auto-converts as much as it can to Python 3.  Case study: porting chardet to Python 3 describes how to run the 2to3 script, then shows some things it can't fix automatically.  This appendix documents what it can fix automatically.
-
    print statement
    
-
    In Python 2, print was a statement.  Whatever you wanted to print simply followed the print keyword.  In Python 3, print() is a function — whatever you want to print is passed to print() like any other function.
-
    skip over this table
-
+
    Diving in
    
+
    Python 3 comes with a utility script called 2to3, which takes your actual Python 2 source code as input and auto-converts as much as it can to Python 3. Case study: porting chardet to Python 3 describes how to run the 2to3 script, then shows some things it can't fix automatically. This appendix documents what it can fix automatically.
+
    print statement
    
+
    In Python 2, print was a statement. Whatever you wanted to print simply followed the print keyword. In Python 3, print() is a function — whatever you want to print is passed to print() like any other function.
+
    skip over this table
+
    
-
-
-
+
+
+
@@ -105,17 +104,17 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
    
 
    NotesPython 2Python 3NotesPython 2Python 3
 
    
 
    ①
 printprint >>sys.stderr, 1, 2, 3
 print(1, 2, 3, file=sys.stderr)
    
 
    
-
      
+
        
 
      1. To print a blank line, call print() without any arguments.
 
      2. To print a single value, call print() with one argument
 
      3. To print two values separated by a space, call print() with two arguments.
-
      4. This one is a little tricky.  In Python 2, if you ended a print statement with a comma, it would print the values separated by spaces, then print a trailing space, then stop without printing a carriage return.  In Python 3, the way to do this is to pass end=' ' as a keyword argument to the print() function.  The end argument defaults to '\n' (a carriage return), so overriding it will suppress the carriage return after printing the other arguments.
-
      5. In Python 2, you could redirect the output to a pipe — like sys.stderr — by using the >>pipe_name syntax.  In Python 3, the way to do this is to pass the pipe in the file keyword argument.  The file argument defaults to sys.stdout (standard out), so overriding it will output to a different pipe instead.
+
      6. This one is a little tricky. In Python 2, if you ended a print statement with a comma, it would print the values separated by spaces, then print a trailing space, then stop without printing a carriage return. In Python 3, the way to do this is to pass end=' ' as a keyword argument to the print() function. The end argument defaults to '\n' (a carriage return), so overriding it will suppress the carriage return after printing the other arguments.
+
      7. In Python 2, you could redirect the output to a pipe — like sys.stderr — by using the >>pipe_name syntax. In Python 3, the way to do this is to pass the pipe in the file keyword argument. The file argument defaults to sys.stdout (standard out), so overriding it will output to a different pipe instead.
 
      
-
      Unicode string literals
      
-
      Python 2 had two string types: Unicode strings and non-Unicode strings.  Python 3 has one string type: Unicode strings.
-
      skip over this table
-
+
      Unicode string literals
      
+
      Python 2 had two string types: Unicode strings and non-Unicode strings. Python 3 has one string type: Unicode strings.
+
      skip over this table
+
      
@@ -127,14 +126,14 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
      
 
      Notes
 Python 2
 Python 3ur"PapayaWhip\foo"
 r"PapayaWhip\foo"
      
 
      
-
        
+
          
 
        1. Unicode string literals are simply converted into string literals, which, in Python 3, are always Unicode.
-
        2. Unicode raw strings (in which Python does not auto-escape backslashes) are converted to raw strings.  In Python 3, raw strings are always Unicode.
+
        3. Unicode raw strings (in which Python does not auto-escape backslashes) are converted to raw strings. In Python 3, raw strings are always Unicode.
 
        
-
        unicode() global function
        
-
        Python 2 had two global functions to coerce objects into strings: unicode() to coerce them into Unicode strings, and str() to coerce them into non-Unicode strings.  Python 3 has only one string type, Unicode strings, so the str() function is all you need.  (The unicode() function no longer exists.)
-
        skip over this table
-
+
        unicode() global function
        
+
        Python 2 had two global functions to coerce objects into strings: unicode() to coerce them into Unicode strings, and str() to coerce them into non-Unicode strings. Python 3 has only one string type, Unicode strings, so the str() function is all you need. (The unicode() function no longer exists.)
+
        skip over this table
+
        
@@ -143,12 +142,12 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
        
 
        Notes
 Python 2
 Python 3unicode(anything)
 str(anything)
        
 
        
-
        
-
        long data type
        
-
        Python 2 had separate int and long types for non-floating-point numbers.  An int could not be any larger than sys.maxint, which varied by platform.  Longs were defined by appending an L to the end of the number, and they could be, well, longer than ints.  In Python 3, there is only one integer type, called int, which mostly behaves like the long type in Python 2.  Since there are no longer two types, there is no need for special syntax to distinguish them.
-
        Further reading: PEP 237: Unifying Long Integers and Integers.
-
        skip over this table
-
+
        
+
        long data type
        
+
        Python 2 had separate int and long types for non-floating-point numbers. An int could not be any larger than sys.maxint, which varied by platform. Longs were defined by appending an L to the end of the number, and they could be, well, longer than ints. In Python 3, there is only one integer type, called int, which mostly behaves like the long type in Python 2. Since there are no longer two types, there is no need for special syntax to distinguish them.
+
        Further reading: PEP 237: Unifying Long Integers and Integers.
+
        skip over this table
+
        
@@ -169,17 +168,17 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
        
 
        Notes
 Python 2
 Python 3isinstance(x, long)
 isinstance(x, int)
        
 
        
-
          
+
            
 
          1. Base 10 long integer literals become base 10 integer literals.
 
          2. Base 16 long integer literals become base 16 integer literals.
-
          3. In Python 3, the old long() function no longer exists, since longs don't exist.  To coerce a variable to an integer, use the int() function.
+
          4. In Python 3, the old long() function no longer exists, since longs don't exist. To coerce a variable to an integer, use the int() function.
 
          5. To check whether a variable is an integer, get its type and compare it to int, not long.
 
          6. You can also use the isinstance() function to check data types; again, use int, not long, to check for integers.
 
          
-
          <> comparison
          
-
          Python 2 supported <> as a synonym for !=, the not-equals comparison operator.  Python 3 supports the != operator, but not <>.
-
          skip over this table
-
+
          <> comparison
          
+
          Python 2 supported <> as a synonym for !=, the not-equals comparison operator. Python 3 supports the != operator, but not <>.
+
          skip over this table
+
          
@@ -191,14 +190,14 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
          
 
          Notes
 Python 2
 Python 3if x <> y <> z:
 if x != y != z:
          
 
          
-
            
+
              
 
            1. A simple comparison.
 
            2. A more complex comparison between three values.
 
            
-
            has_key() dictionary method
            
-
            In Python 2, dictionaries had a has_key() method to test whether the dictionary had a certain key.  In Python 3, this method no longer exists.  Instead, you need to use the in operator.
-
            skip over this table
-
+
            has_key() dictionary method
            
+
            In Python 2, dictionaries had a has_key() method to test whether the dictionary had a certain key. In Python 3, this method no longer exists. Instead, you need to use the in operator.
+
            skip over this table
+
            
@@ -219,17 +218,17 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
            
 
            Notes
 Python 2
 Python 3x + a_dictionary.has_key(y)
 x + (y in a_dictionary)
            
 
            
-
              
+
                
 
              1. The simplest form.
 
              2. The or operator takes precedence over the in operator, so there is no need for parentheses here.
 
              3. On the other hand, you do need parentheses here, for the same reason — or takes precedence over in.
 
              4. The in operator takes precedence over the + operator, so this form needs parentheses too.
 
              5. Again with the parentheses, for the same reason.
 
              
-
              Dictionary methods that return lists
              
-
              In Python 2, many dictionary methods returned lists.  The most frequently used methods were keys(), items(), and values().  In Python 3, all of these methods return dynamic views.  In some contexts, this is not a problem.  If the method's return value is immediately passed to another function that iterates through the entire sequence, it makes no difference whether the actual type is a list or a view.  In other contexts, it matters a great deal.  If you were expecting a complete list with individually addressable elements, your code will choke, because views do not support indexing.
-
              skip over this table
-
+
              Dictionary methods that return lists
              
+
              In Python 2, many dictionary methods returned lists. The most frequently used methods were keys(), items(), and values(). In Python 3, all of these methods return dynamic views. In some contexts, this is not a problem. If the method's return value is immediately passed to another function that iterates through the entire sequence, it makes no difference whether the actual type is a list or a view. In other contexts, it matters a great deal. If you were expecting a complete list with individually addressable elements, your code will choke, because views do not support indexing.
+
              skip over this table
+
              
@@ -250,19 +249,19 @@ h3:before{counter-increment:h3;content:"A." counter(h2) "." counter(h3) ". "}
 
              
 
              Notes
 Python 2
 Python 3min(a_dictionary.keys())
 no change
              
 
              
-
                
-
              1. 2to3 errs on the side of safety, converting the return value from keys() to a static list with the list() function.  This will always work, but it will be less efficient than using a view.  You should examine the converted code to see if a list is absolutely necessary, or if a view would do.
-
              2. Another view-to-list conversion, with the items() method.  2to3 will do the same thing with the values() method.
-
              3. Python 3 does not support the iterkeys() method anymore.  Use keys(), and if necessary, convert the view to an iterator with the iter() function.
-
              4. 2to3 recognizes when the iterkeys() method is used inside a list comprehension, and converts it to the keys() method (without wrapping it in an extra call to iter()).  This works because views are iterable.
-
              5. 2to3 recognizes that the keys() method is immediately passed to a function which iterates through an entire sequence, so there is no need to convert the return value to a list first.  The min() function will happily iterate through the view instead.  This applies to min(), max(), sum(), list(), tuple(), set(), sorted(), any(), and all().
+
                  
+
                1. 2to3 errs on the side of safety, converting the return value from keys() to a static list with the list() function. This will always work, but it will be less efficient than using a view. You should examine the converted code to see if a list is absolutely necessary, or if a view would do.
+
                2. Another view-to-list conversion, with the items() method. 2to3 will do the same thing with the values() method.
+
                3. Python 3 does not support the iterkeys() method anymore. Use keys(), and if necessary, convert the view to an iterator with the iter() function.
+
                4. 2to3 recognizes when the iterkeys() method is used inside a list comprehension, and converts it to the keys() method (without wrapping it in an extra call to iter()). This works because views are iterable.
+
                5. 2to3 recognizes that the keys() method is immediately passed to a function which iterates through an entire sequence, so there is no need to convert the return value to a list first. The min() function will happily iterate through the view instead. This applies to min(), max(), sum(), list(), tuple(), set(), sorted(), any(), and all().
 
                
-
                Modules that have been renamed or reorganized
                
-
                Several modules in the Python Standard Library have been renamed.  Several other modules which are related to each other have been combined or reorganized to make their association more logical.
-
                http
                
+
                Modules that have been renamed or reorganized
                
+
                Several modules in the Python Standard Library have been renamed. Several other modules which are related to each other have been combined or reorganized to make their association more logical.
+
                http
                
 
                In Python 3, several related HTTP modules have been combined into a single package, http.
-
                skip over this table
-
+
                skip over this table
+
                
@@ -282,16 +281,16 @@ import SimpleHTTPServer
 import CGIHttpServer
                
 
                Notes
 Python 2
 Python 3
 import http.server
                
 
                
-
                  
+
                    
 
                  1. The http.client module implements a low-level library that can request HTTP resources and interpret HTTP responses.
 
                  2. The http.cookies module provides a Pythonic interface to browser cookies that are sent in a Set-Cookie: HTTP header.
 
                  3. The http.cookiejar module manipulates the actual files on disk that popular web browsers use to store cookies.
 
                  4. The http.server module provides a basic HTTP server.
 
                  
-
                  urllib
                  
-
                  Python 2 had a rat's nest of overlapping modules to parse, encode, and fetch URLs.  In Python 3, these have all been refactored and combined in a single package, urllib.
-
                  skip over this table
-
+
                  urllib
                  
+
                  Python 2 had a rat's nest of overlapping modules to parse, encode, and fetch URLs. In Python 3, these have all been refactored and combined in a single package, urllib.
+
                  skip over this table
+
                  
@@ -319,18 +318,18 @@ from urllib2 import HTTPError
                  
 
                  Notes
 Python 2
 Python 3
 
                  from urllib.request import Request
 from urllib.error import HTTPError
                  
 
                  
-
                    
-
                  1. The old urllib module in Python 2 had a variety of functions, including urlopen() for fetching data and splittype(), splithost(), and splituser() for splitting a URL into its constituent parts.  These functions have been reorganized more logically within the new urllib package.  2to3 will also change all calls to these functions so they use the new naming scheme.
-
                  2. The old urllib2 module in Python 2 has been folded into into the urllib package in Python 3.  All your urllib2 favorites — the build_opener() method, Request objects, and HTTPBasicAuthHandler and friends — are still available.
+
                      
+
                    1. The old urllib module in Python 2 had a variety of functions, including urlopen() for fetching data and splittype(), splithost(), and splituser() for splitting a URL into its constituent parts. These functions have been reorganized more logically within the new urllib package. 2to3 will also change all calls to these functions so they use the new naming scheme.
+
                    2. The old urllib2 module in Python 2 has been folded into into the urllib package in Python 3. All your urllib2 favorites — the build_opener() method, Request objects, and HTTPBasicAuthHandler and friends — are still available.
 
                    3. The urllib.parse module in Python 3 contains all the parsing functions from the old urlparse module in Python 2.
-
                    4. The urllib.robotparser module parses robots.txt files.
-
                    5. The FancyURLopener class, which handles HTTP redirects and other status codes, is still available in the new urllib.request module.  The urlencode function has moved to urllib.parse.
+
                    6. The urllib.robotparser module parses robots.txt files.
+
                    7. The FancyURLopener class, which handles HTTP redirects and other status codes, is still available in the new urllib.request module. The urlencode function has moved to urllib.parse.
 
                    8. The Request object is still available in urllib.request, but constants like HTTPError have been moved to urllib.error.
 
                    
-
                    dbm
                    
-
                    All the various DBM clones are now in a single package, dbm.  If you need a specific variant like GNU DBM, you can import the appropriate module within the dbm package.
-
                    skip over this table
-
+
                    dbm
                    
+
                    All the various DBM clones are now in a single package, dbm. If you need a specific variant like GNU DBM, you can import the appropriate module within the dbm package.
+
                    skip over this table
+
                    
@@ -352,11 +351,11 @@ from urllib.error import HTTPError
 import whichdb
                    
 
                    Notes
 Python 2
 Python 3
                    
 
                    import dbm
                    
 
                    
-
                    
-
                    xmlrpc
                    
-
                    XML-RPC is a lightweight method of performing remote RPC calls over HTTP.  The XML-RPC client library and several XML-RPC server implementations are now combined in a single package, xmlrpc.
-
                    skip over this table
-
+
                    
+
                    xmlrpc
                    
+
                    XML-RPC is a lightweight method of performing remote RPC calls over HTTP. The XML-RPC client library and several XML-RPC server implementations are now combined in a single package, xmlrpc.
+
                    skip over this table
+
                    
@@ -369,10 +368,10 @@ import whichdb
 import SimpleXMLRPCServer
                    
 
                    Notes
 Python 2
 Python 3
 import xmlrpc.server
                    
 
                    
-
                    
-
                    Other modules
                    
-
                    skip over this table
-
+
                    
+
                    Other modules
                    
+
                    skip over this table
+
                    
@@ -411,10 +410,10 @@ except ImportError:
 
                    
 
                    Notes
 Python 2
 Python 3import commands
 import subprocess
                    
 
                    
-
                      
-
                    1. A common idiom in Python 2 was to try to import cStringIO as StringIO, and if that failed, to import StringIO instead.  Do not do this in Python 3; the io module does it for you.  It will find the fastest implementation available and use it automatically.
-
                    2. A similar idiom was used to import the fastest pickle implementation.  Do not do this in Python 3; the pickle module does it for you.
-
                    3. The builtins module contains the global functions, classes, and constants used throughout the Python language.  Redefining a function in the builtins module will redefine the global function everywhere.  That is exactly as powerful and scary as it sounds.
+
                        
+
                      1. A common idiom in Python 2 was to try to import cStringIO as StringIO, and if that failed, to import StringIO instead. Do not do this in Python 3; the io module does it for you. It will find the fastest implementation available and use it automatically.
+
                      2. A similar idiom was used to import the fastest pickle implementation. Do not do this in Python 3; the pickle module does it for you.
+
                      3. The builtins module contains the global functions, classes, and constants used throughout the Python language. Redefining a function in the builtins module will redefine the global function everywhere. That is exactly as powerful and scary as it sounds.
 
                      4. The copyreg module adds pickle support for custom types defined in C.
 
                      5. The queue module implements a multi-producer, multi-consumer queue.
 
                      6. The socketserver module provides generic base classes for implementing different kinds of socket servers.
@@ -422,10 +421,10 @@ except ImportError:
 
                      7. The reprlib module reimplements the built-in repr() function, but with limits on how many values are represented.
 
                      8. The subprocess module allows you to spawn processes, connect to their pipes, and obtain their return codes.
 
                      
-
                      Relative imports within a package
                      
-
                      A package is a group of related modules that function as a single entity.  In Python 2, when modules within a package need to reference each other, you use import foo or from foo import Bar.  The Python 2 interpreter first searches within the current package to find foo.py, and then moves on to the other directories in the Python search path (sys.path).  Python 3 works a bit differently.  Instead of searching the current package, it goes directly to the Python search path.  If you want one module within a package to import another module in the same package, you need to explicitly provide the relative path between the two modules.
+
                      Relative imports within a package
                      
+
                      A package is a group of related modules that function as a single entity. In Python 2, when modules within a package need to reference each other, you use import foo or from foo import Bar. The Python 2 interpreter first searches within the current package to find foo.py, and then moves on to the other directories in the Python search path (sys.path). Python 3 works a bit differently. Instead of searching the current package, it goes directly to the Python search path. If you want one module within a package to import another module in the same package, you need to explicitly provide the relative path between the two modules.
 
                      Suppose you had this package, with multiple files in the same directory:
-
                      skip over this ASCII art
+
                      skip over this ASCII art
 
                      chardet/
 |
 +--__init__.py
@@ -435,9 +434,9 @@ except ImportError:
 +--mbcharsetprober.py
 |
 +--universaldetector.py
                      
-
                      Now suppose that universaldetector.py needs to import the entire constants.py file and one class from mbcharsetprober.py.  How do you do it?
-
                      skip over this table
-
+
                      Now suppose that universaldetector.py needs to import the entire constants.py file and one class from mbcharsetprober.py. How do you do it?
+
                      skip over this table
+
                      
@@ -449,14 +448,14 @@ except ImportError:
 
                      
 
                      Notes
 Python 2
 Python 3from mbcharsetprober import MultiByteCharSetProber
 from .mbcharsetprober import MultiByteCharsetProber
                      
 
                      
-
                        
-
                      1. When you need to import an entire module from elsewhere in your package, use the new from . import syntax.  The period is actually a relative path from this file (universaldetector.py) to the file you want to import (constants.py).  In this case, they are in the same directory, thus the single period.  You can also import from the parent directory (from .. import anothermodule) or a subdirectory.
-
                      2. To import a specific class or function from another module directly into your module's namespace, prefix the target module with a relative path, minus the trailing slash.  In this case, mbcharsetprober.py is in the same directory as universaldetector.py, so the path is a single period.  You can also import form the parent directory (from ..anothermodule import AnotherClass) or a subdirectory.
+
                          
+
                        1. When you need to import an entire module from elsewhere in your package, use the new from . import syntax. The period is actually a relative path from this file (universaldetector.py) to the file you want to import (constants.py). In this case, they are in the same directory, thus the single period. You can also import from the parent directory (from .. import anothermodule) or a subdirectory.
+
                        2. To import a specific class or function from another module directly into your module's namespace, prefix the target module with a relative path, minus the trailing slash. In this case, mbcharsetprober.py is in the same directory as universaldetector.py, so the path is a single period. You can also import form the parent directory (from ..anothermodule import AnotherClass) or a subdirectory.
 
                        
-
                        next() iterator method
                        
-
                        In Python 2, iterators had a next() method which returned the next item in the sequence.  That's still true in Python 3, but there is now also a global next() function that takes an iterator as an argument.
-
                        skip over this table
-
+
                        next() iterator method
                        
+
                        In Python 2, iterators had a next() method which returned the next item in the sequence. That's still true in Python 3, but there is now also a global next() function that takes an iterator as an argument.
+
                        skip over this table
+
                        
@@ -487,17 +486,17 @@ for an_iterator in a_sequence_of_iterators:
 for an_iterator in a_sequence_of_iterators:
     an_iterator.__next__()
                        
 
                        Notes
 Python 2
 Python 3
                        
 
                        
-
                          
+
                            
 
                          1. In the simplest case, instead of calling an iterator's next() method, you now pass the iterator itself to the global next() function.
-
                          2. If you have a function that returns an iterator, call the function and pass the result to the next() function.  (The 2to3 script is smart enough to convert this properly.)
+
                          3. If you have a function that returns an iterator, call the function and pass the result to the next() function. (The 2to3 script is smart enough to convert this properly.)
 
                          4. If you define your own class and mean to use it as an iterator, define the __next__() special method.
-
                          5. If you define your own class and just happen to have a method named next() that takes one or more arguments, 2to3 will not touch it.  This class can not be used as an iterator, because its next() method takes arguments.
-
                          6. This one is a bit tricky.  If you have a local variable named next, then it takes precedence over the new global next() function.  In this case, you need to call the iterator's special __next()__ method to get the next item in the sequence.  (Alternatively, you could also refactor the code so the local variable wasn't named next, but 2to3 will not do that for you automatically.)
+
                          7. If you define your own class and just happen to have a method named next() that takes one or more arguments, 2to3 will not touch it. This class can not be used as an iterator, because its next() method takes arguments.
+
                          8. This one is a bit tricky. If you have a local variable named next, then it takes precedence over the new global next() function. In this case, you need to call the iterator's special __next()__ method to get the next item in the sequence. (Alternatively, you could also refactor the code so the local variable wasn't named next, but 2to3 will not do that for you automatically.)
 
                          
-
                          filter() global function
                          
-
                          In Python 2, the filter() function returned a list, the result of filtering a sequence through a function that returned True or False for each item in the sequence.  In Python 3, the filter() function returns an iterator, not a list.
-
                          skip over this table
-
+
                          filter() global function
                          
+
                          In Python 2, the filter() function returned a list, the result of filtering a sequence through a function that returned True or False for each item in the sequence. In Python 3, the filter() function returns an iterator, not a list.
+
                          skip over this table
+
                          
@@ -518,17 +517,17 @@ for an_iterator in a_sequence_of_iterators:
 
                          
 
                          Notes
 Python 2
 Python 3[i for i in filter(a_function, a_sequence)]
 no change
                          
 
                          
-
                            
+
                              
 
                            1. In the most basic case, 2to3 will wrap a call to filter() with a call to list(), which simply iterates through its argument and returns a real list.
 
                            2. However, if the call to filter() is already wrapped in list(), 2to3 will do nothing, since the fact that filter() is returning an iterator is irrelevant.
 
                            3. For the special syntax of filter(None, ...), 2to3 will transform the call into a semantically equivalent list comprehension.
 
                            4. In contexts like for loops, which iterate through the entire sequence anyway, no changes are necessary.
 
                            5. Again, no changes are necessary, because the list comprehension will iterate through the entire sequence, and it can do that just as well if filter() returns an iterator as if it returns a list.
 
                            
-
                            map() global function
                            
-
                            In much the same way as filter(), the map() function now returns an iterator.  (In Python 2, it returned a list.)
-
                            skip over this table
-
+
                            map() global function
                            
+
                            In much the same way as filter(), the map() function now returns an iterator. (In Python 2, it returned a list.)
+
                            skip over this table
+
                            
@@ -549,17 +548,17 @@ for an_iterator in a_sequence_of_iterators:
 
                            
 
                            Notes
 Python 2
 Python 3[i for i in map(a_function, a_sequence)]
 no change
                            
 
                            
-
                              
+
                                
 
                              1. As with filter(), in the most basic case, 2to3 will wrap a call to map() with a call to list().
 
                              2. For the special syntax of map(None, ...), the identity function, 2to3 will convert it to an equivalent call to list().
 
                              3. If the first argument to map() is a lambda function, 2to3 will convert it to an equivalent list comprehension.
 
                              4. In contexts like for loops, which iterate through the entire sequence anyway, no changes are necessary.
 
                              5. Again, no changes are necessary, because the list comprehension will iterate through the entire sequence, and it can do that just as well if map() returns an iterator as if it returns a list.
 
                              
-
                              reduce() global function (3.1+)
                              
+
                              reduce() global function (3.1+)
                              
 
                              In Python 3, the reduce() function has been removed from the global namespace and placed in the functools module.
-
                              skip over this table
-
+
                              skip over this table
+
                              
@@ -569,13 +568,13 @@ for an_iterator in a_sequence_of_iterators:
 
                              
 
                              Notes
 Python 2
 Python 3
                              from functtools import reduce
 reduce(a, b, c)
                              
 
                              
-
                              
-
                              ☞The version of 2to3 that shipped with Python 3.0 would not fix the reduce() function automatically.  The fix first appeared in the 2to3 script that shipped with Python 3.1.
+
                              
+
                              ☞The version of 2to3 that shipped with Python 3.0 would not fix the reduce() function automatically. The fix first appeared in the 2to3 script that shipped with Python 3.1.
 
                              
-
                              apply() global function
                              
-
                              Python 2 had a global function called apply(), which took a function f and a list [a, b, c] and returned f(a, b, c).  In Python 3, the apply() function no longer exists.  Instead, there is a new function calling syntax that allows you to pass a list and have Python apply the list as the function's arguments.
-
                              skip over this table
-
+
                              apply() global function
                              
+
                              Python 2 had a global function called apply(), which took a function f and a list [a, b, c] and returned f(a, b, c). In Python 3, the apply() function no longer exists. Instead, there is a new function calling syntax that allows you to pass a list and have Python apply the list as the function's arguments.
+
                              skip over this table
+
                              
@@ -593,16 +592,16 @@ reduce(a, b, c)
                              
 
                              Notes
 Python 2
 Python 3
                              
 
                              apply(aModule.a_function, a_list_of_args)
 aModule.a_function(*a_list_of_args)
                              
 
                              
-
                                
-
                              1. In the simplest form, you can call a function with a list of arguments (an actual list like [a, b, c]) by prepending the list with an asterisk (*).  This is exactly equivalent to the old apply() function in Python 2.
-
                              2. In Python 2, the apply() function could actually take three parameters: a function, a list of arguments, and a dictionary of named arguments.  In Python 3, you can accomplish the same thing by prepending the list of arguments with an asterisk (*) and the dictionary of named arguments with two asterisks (**).
+
                                  
+
                                1. In the simplest form, you can call a function with a list of arguments (an actual list like [a, b, c]) by prepending the list with an asterisk (*). This is exactly equivalent to the old apply() function in Python 2.
+
                                2. In Python 2, the apply() function could actually take three parameters: a function, a list of arguments, and a dictionary of named arguments. In Python 3, you can accomplish the same thing by prepending the list of arguments with an asterisk (*) and the dictionary of named arguments with two asterisks (**).
 
                                3. The + operator, used here for list concatenation, takes precedence over the * operator, so there is no need for extra parentheses around a_list_of_args + z.
 
                                4. The 2to3 script is smart enough to convert complex apply() calls, including calling functions within imported modules.
 
                                
-
                                intern() global function
                                
-
                                In Python 2, you could call the intern() function on a string to intern it as a performance optimization.  In Python 3, the intern() function has been moved to the sys module.
-
                                skip over this table
-
+
                                intern() global function
                                
+
                                In Python 2, you could call the intern() function on a string to intern it as a performance optimization. In Python 3, the intern() function has been moved to the sys module.
+
                                skip over this table
+
                                
@@ -611,11 +610,11 @@ reduce(a, b, c)
                                
 
                                Notes
 Python 2
 Python 3
                                
 
                                intern(aString)
 sys.intern(aString)
                                
 
                                
-
                                
-
                                exec statement
                                
-
                                Just as the print statement became a function in Python 3, so too has the exec statement.  The exec() function takes a string which contains arbitrary Python code and executes it as if it were just another statement or expression.
-
                                skip over this table
-
+
                                
+
                                exec statement
                                
+
                                Just as the print statement became a function in Python 3, so too has the exec statement. The exec() function takes a string which contains arbitrary Python code and executes it as if it were just another statement or expression.
+
                                skip over this table
+
                                
@@ -630,15 +629,15 @@ reduce(a, b, c)
                                
 
                                Notes
 Python 2
 Python 3
                                
 
                                exec codeString in a_global_namespace, a_local_namespace
 exec(codeString, a_global_namespace, a_local_namespace)
                                
 
                                
-
                                  
+
                                    
 
                                  1. In the simplest form, the 2to3 script simply encloses the code-as-a-string in parentheses, since exec() is now a function instead of a statement.
-
                                  2. The old exec statement could take a namespace, a private environment of globals in which the code-as-a-string would be executed.  Python 3 can also do this; just pass the namespace as the second argument to the exec() function.
-
                                  3. Even fancier, the old exec statement could also take a local namespace (like the variables defined within a function).  In Python 3, the exec() function can do that too.
+
                                  4. The old exec statement could take a namespace, a private environment of globals in which the code-as-a-string would be executed. Python 3 can also do this; just pass the namespace as the second argument to the exec() function.
+
                                  5. Even fancier, the old exec statement could also take a local namespace (like the variables defined within a function). In Python 3, the exec() function can do that too.
 
                                  
-
                                  execfile statement (3.1+)
                                  
-
                                  Like the old exec statement, the old execfile statement will execute strings as if they were Python code.  Where exec took a string, execfile took a filename.  In Python 3, the execfile statement has been eliminated.  If you really need to take a file of Python code and execute it (but you're not willing to simply import it), you can accomplish the same thing by opening the file, reading its contents, calling the global compile() function to force the Python interpreter to compile the code, and then call the new exec() function.
-
                                  skip over this table
-
+
                                  execfile statement (3.1+)
                                  
+
                                  Like the old exec statement, the old execfile statement will execute strings as if they were Python code. Where exec took a string, execfile took a filename. In Python 3, the execfile statement has been eliminated. If you really need to take a file of Python code and execute it (but you're not willing to simply import it), you can accomplish the same thing by opening the file, reading its contents, calling the global compile() function to force the Python interpreter to compile the code, and then call the new exec() function.
+
                                  skip over this table
+
                                  
@@ -647,13 +646,13 @@ reduce(a, b, c)
                                  
 
                                  Notes
 Python 2
 Python 3
                                  
 
                                  execfile("a_filename")
 exec(compile(open("a_filename").read(), "a_filename", "exec"))
                                  
 
                                  
-
                                  
-
                                  ☞The version of 2to3 that shipped with Python 3.0 would not fix the execfile statement automatically.  The fix first appeared in the 2to3 script that shipped with Python 3.1.
+
                                  
+
                                  ☞The version of 2to3 that shipped with Python 3.0 would not fix the execfile statement automatically. The fix first appeared in the 2to3 script that shipped with Python 3.1.
 
                                  
-
                                  repr literals (backticks)
                                  
-
                                  In Python 2, there was a special syntax of wrapping any object in backticks (like `x`) to get a representation of the object.  In Python 3, this capability still exists, but you can no longer use backticks to get it.  Instead, use the global repr() function.
-
                                  skip over this table
-
+
                                  repr literals (backticks)
                                  
+
                                  In Python 2, there was a special syntax of wrapping any object in backticks (like `x`) to get a representation of the object. In Python 3, this capability still exists, but you can no longer use backticks to get it. Instead, use the global repr() function.
+
                                  skip over this table
+
                                  
@@ -665,14 +664,14 @@ reduce(a, b, c)
                                  
 
                                  Notes
 Python 2
 Python 3
                                  
 
                                  `"PapayaWhip" + `2``
 repr("PapayaWhip" + repr(2))
                                  
 
                                  
-
                                    
-
                                  1. Remember, x can be anything — a class, a function, a module, a primitive data type, etc.  The repr() function works on everything.
-
                                  2. In Python 2, backticks could be nested, leading to this sort of confusing (but valid) expression.  The 2to3 tool is smart enough to convert this into nested calls to repr().
+
                                      
+
                                    1. Remember, x can be anything — a class, a function, a module, a primitive data type, etc. The repr() function works on everything.
+
                                    2. In Python 2, backticks could be nested, leading to this sort of confusing (but valid) expression. The 2to3 tool is smart enough to convert this into nested calls to repr().
 
                                    
-
                                    try...except statement
                                    
+
                                    try...except statement
                                    
 
                                    The syntax for catching exceptions has changed slightly between Python 2 and Python 3.
-
                                    skip over this table
-
+
                                    skip over this table
+
                                    
@@ -708,19 +707,19 @@ except:
     pass
                                    
 
                                    Notes
 Python 2
 Python 3
 no change
                                    
 
                                    
-
                                      
+
                                        
 
                                      1. Instead of a comma after the exception type, Python 3 uses a new keyword, as.
 
                                      2. The as keyword also works for catching multiple types of exceptions at once.
 
                                      3. If you catch an exception but don't actually care about accessing the exception object itself, the syntax is identical between Python 2 and Python 3.
 
                                      4. Similarly, if you use a fallback to catch all exceptions, the syntax is identical.
 
                                      
-
                                      
-
                                      ☞You should never use a fallback to catch all exceptions when importing modules (or most other times).  Doing so will catch things like KeyboardInterrupt (if the user pressed Ctrl-C to interrupt the program) and can make it more difficult to debug errors.
+
                                      
+
                                      ☞You should never use a fallback to catch all exceptions when importing modules (or most other times). Doing so will catch things like KeyboardInterrupt (if the user pressed Ctrl-C to interrupt the program) and can make it more difficult to debug errors.
 
                                      
-
                                      raise statement
                                      
+
                                      raise statement
                                      
 
                                      The syntax for raising your own exceptions has changed slightly between Python 2 and Python 3.
-
                                      skip over this table
-
+
                                      skip over this table
+
                                      
@@ -738,16 +737,16 @@ except:
 
                                      
 
                                      Notes
 Python 2
 Python 3raise "error message"
 unsupported
                                      
 
                                      
-
                                        
+
                                          
 
                                        1. In the simplest form, raising an exception without a custom error message, the syntax is unchanged.
-
                                        2. The change becomes noticeable when you want to raise an exception with a custom error message.  Python 2 separated the exception class and the message with a comma; Python 3 passes the error message as a parameter.
-
                                        3. Python 2 supported a more complex syntax to raise an exception with a custom traceback (stack trace).  You can do this in Python 3 as well, but the syntax is quite different.
-
                                        4. In Python 2, you could raise an exception with no exception class, just an error message.  In Python 3, this is no longer possible.  2to3 will warn you that it was unable to fix this automatically.
+
                                        5. The change becomes noticeable when you want to raise an exception with a custom error message. Python 2 separated the exception class and the message with a comma; Python 3 passes the error message as a parameter.
+
                                        6. Python 2 supported a more complex syntax to raise an exception with a custom traceback (stack trace). You can do this in Python 3 as well, but the syntax is quite different.
+
                                        7. In Python 2, you could raise an exception with no exception class, just an error message. In Python 3, this is no longer possible. 2to3 will warn you that it was unable to fix this automatically.
 
                                        
-
                                        throw method on generators
                                        
-
                                        In Python 2, generators have a throw() method.  Calling a_generator.throw() raises an exception at the point where the generator was paused, then returns the next value yielded by the generator function.  In Python 3, this functionality is still available, but the syntax is slightly different.
-
                                        skip over this table
-
+
                                        throw method on generators
                                        
+
                                        In Python 2, generators have a throw() method. Calling a_generator.throw() raises an exception at the point where the generator was paused, then returns the next value yielded by the generator function. In Python 3, this functionality is still available, but the syntax is slightly different.
+
                                        skip over this table
+
                                        
@@ -762,15 +761,15 @@ except:
 
                                        
 
                                        Notes
 Python 2
 Python 3a_generator.throw("error message")
 unsupported
                                        
 
                                        
-
                                          
-
                                        1. In the simplest form, a generator throws an exception without a custom error message.  In this case, the syntax has not changed between Python 2 and Python 3.
+
                                            
+
                                          1. In the simplest form, a generator throws an exception without a custom error message. In this case, the syntax has not changed between Python 2 and Python 3.
 
                                          2. If the generator throws an exception with a custom error message, you need to pass the error string to the exception when you create it.
-
                                          3. Python 2 also supported throwing an exception with only a custom error message.  Python 3 does not support this, and the 2to3 script will display a warning telling you that you will need to fix this code manually.
+
                                          4. Python 2 also supported throwing an exception with only a custom error message. Python 3 does not support this, and the 2to3 script will display a warning telling you that you will need to fix this code manually.
 
                                          
-
                                          xrange() global function
                                          
-
                                          In Python 2, there were two ways to get a range of numbers: range(), which returned a list, and xrange(), which returned an iterator.  In Python 3, range() returns an iterator, and xrange() doesn't exist.
-
                                          skip over this table
-
+
                                          xrange() global function
                                          
+
                                          In Python 2, there were two ways to get a range of numbers: range(), which returned a list, and xrange(), which returned an iterator. In Python 3, range() returns an iterator, and xrange() doesn't exist.
+
                                          skip over this table
+
                                          
@@ -791,17 +790,17 @@ except:
 
                                          
 
                                          Notes
 Python 2
 Python 3sum(range(10))
 no change
                                          
 
                                          
-
                                            
+
                                              
 
                                            1. In the simplest case, the 2to3 script will simply convert xrange() to range().
-
                                            2. If your Python 2 code used range(), the 2to3 script does not know whether you needed a list, or whether an iterator would do.  It errs on the side of caution and coerces the return value into a list by calling the list() function.
+
                                            3. If your Python 2 code used range(), the 2to3 script does not know whether you needed a list, or whether an iterator would do. It errs on the side of caution and coerces the return value into a list by calling the list() function.
 
                                            4. If the xrange() function was inside a list comprehension, there is no need to coerce the result to a list, since the list comprehension will work just fine with an iterator.
 
                                            5. Similarly, a for loop will work just fine with an iterator, so there is no need to change anything here.
-
                                            6. The sum() function will also work with an iterator, so 2to3 makes no changes here either.  Like dictionary methods that return views instead of lists, this applies to min(), max(), sum(), list(), tuple(), set(), sorted(), any(), and all().
+
                                            7. The sum() function will also work with an iterator, so 2to3 makes no changes here either. Like dictionary methods that return views instead of lists, this applies to min(), max(), sum(), list(), tuple(), set(), sorted(), any(), and all().
 
                                            
-
                                            raw_input() and input() global functions
                                            
-
                                            Python 2 had two global functions for asking the user for input on the command line.  The first, called input(), expected the user to enter a Python expression (and returned the result).  The second, called raw_input(), just returned whatever the user typed.  This was wildly confusing for beginners and widely regarded as a “wart” in the language.  Python 3 excises this wart by renaming raw_input() to input(), so it works the way everyone naively expects it to work.
-
                                            skip over this table
-
+
                                            raw_input() and input() global functions
                                            
+
                                            Python 2 had two global functions for asking the user for input on the command line. The first, called input(), expected the user to enter a Python expression (and returned the result). The second, called raw_input(), just returned whatever the user typed. This was wildly confusing for beginners and widely regarded as a “wart” in the language. Python 3 excises this wart by renaming raw_input() to input(), so it works the way everyone naively expects it to work.
+
                                            skip over this table
+
                                            
@@ -816,15 +815,15 @@ except:
 
                                            
 
                                            Notes
 Python 2
 Python 3input()
 eval(input())
                                            
 
                                            
-
                                              
+
                                                
 
                                              1. In the simplest form, raw_input() becomes input().
-
                                              2. In Python 2, the raw_input() function could take a prompt as a parameter.  This has been retained in Python 3.
+
                                              3. In Python 2, the raw_input() function could take a prompt as a parameter. This has been retained in Python 3.
 
                                              4. If you actually need to ask the user for a Python expression to evaluate, use the input() function and pass the result to eval().
 
                                              
-
                                              func_* function attributes
                                              
-
                                              In Python 2, code within functions can access special attributes about the function itself.  In Python 3, these special function attributes have been renamed for consistency with other attributes.
-
                                              skip over this table
-
+
                                              func_* function attributes
                                              
+
                                              In Python 2, code within functions can access special attributes about the function itself. In Python 3, these special function attributes have been renamed for consistency with other attributes.
+
                                              skip over this table
+
                                              
@@ -851,7 +850,7 @@ except:
 
                                              
 
                                              Notes
 Python 2
 Python 3a_function.func_code
 a_function.__code__
                                              
 
                                              
-
                                                
+
                                                  
 
                                                1. The __name__ attribute (previously func_name) contains the function's name.
 
                                                2. The __doc__ attribute (previously func_doc) contains the docstring that you defined in the function's source code.
 
                                                3. The __defaults__ attribute (previously func_defaults) is a tuple containing default argument values for those arguments that have default values.
@@ -860,10 +859,10 @@ except:
 
                                                4. The __globals__ attribute (previously func_globals) is a reference to the global namespace of the module in which the function was defined.
 
                                                5. The __code__ attribute (previously func_code) is a code object representing the compiled function body.
 
                                                
-
                                                xreadlines() I/O method
                                                
-
                                                In Python 2, file objects had an xreadlines() method which returned an iterator that would read the file one line at a time.  This was useful in for loops, among other places.  In fact, it was so useful, later versions of Python 2 added the capability to file objects themselves.
-
                                                skip over this table
-
+
                                                xreadlines() I/O method
                                                
+
                                                In Python 2, file objects had an xreadlines() method which returned an iterator that would read the file one line at a time. This was useful in for loops, among other places. In fact, it was so useful, later versions of Python 2 added the capability to file objects themselves.
+
                                                skip over this table
+
                                                
@@ -875,14 +874,14 @@ except:
 
                                                
 
                                                Notes
 Python 2
 Python 3for line in a_file.xreadlines(5):
 no change
                                                
 
                                                
-
                                                  
-
                                                1. If you used to call xreadlines() with no arguments, 2to3 will convert it to just the file object.  In Python 3, this will accomplish the same thing: read the file one line at a time and execute the body of the for loop.
-
                                                2. If you used to call xreadlines() with an argument (the number of lines to read at a time), keep doing that.  It still works in Python 3, and 2to3 will not change it.
+
                                                    
+
                                                  1. If you used to call xreadlines() with no arguments, 2to3 will convert it to just the file object. In Python 3, this will accomplish the same thing: read the file one line at a time and execute the body of the for loop.
+
                                                  2. If you used to call xreadlines() with an argument (the number of lines to read at a time), keep doing that. It still works in Python 3, and 2to3 will not change it.
 
                                                  
-
                                                  lambda functions with multiple parameters
                                                  
-
                                                  In Python 2, you could define anonymous lambda functions which took multiple parameters by defining the function as taking a tuple with a specific number of items.  In effect, Python 2 would “unpack” the tuple into named arguments, which you could then reference (by name) within the lambda function.  In Python 3, you can still pass a tuple to a lambda function, but the Python interpreter will not unpack the tuple into named arguments.  Instead, you will need to reference each argument by its positional index.
-
                                                  skip over this table
-
+
                                                  lambda functions with multiple parameters
                                                  
+
                                                  In Python 2, you could define anonymous lambda functions which took multiple parameters by defining the function as taking a tuple with a specific number of items. In effect, Python 2 would “unpack” the tuple into named arguments, which you could then reference (by name) within the lambda function. In Python 3, you can still pass a tuple to a lambda function, but the Python interpreter will not unpack the tuple into named arguments. Instead, you will need to reference each argument by its positional index.
+
                                                  skip over this table
+
                                                  
@@ -897,15 +896,15 @@ except:
 
                                                  
 
                                                  Notes
 Python 2
 Python 3lambda (x, (y, z)): x + y + z
 lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]
                                                  
 
                                                  
-
                                                    
-
                                                  1. If you had defined a lambda function that took a tuple of one item, in Python 3 that would become a lambda with references to x1[0].  The name x1 is autogenerated by the 2to3 script, based on the named arguments in the original tuple.
+
                                                      
+
                                                    1. If you had defined a lambda function that took a tuple of one item, in Python 3 that would become a lambda with references to x1[0]. The name x1 is autogenerated by the 2to3 script, based on the named arguments in the original tuple.
 
                                                    2. A lambda function with a two-item tuple (x, y) gets converted to x_y with positional arguments x_y[0] and x_y[1].
-
                                                    3. The 2to3 script can even handle lambda functions with nested tuples of named arguments.  The resulting Python 3 code is a bit unreadable, but it works the same as the old code did in Python 2.
+
                                                    4. The 2to3 script can even handle lambda functions with nested tuples of named arguments. The resulting Python 3 code is a bit unreadable, but it works the same as the old code did in Python 2.
 
                                                    
-
                                                    Special method attributes
                                                    
-
                                                    In Python 2, class methods can reference the class object they are defined in, as well as the method object itself.   im_self is the class instance object; the class im_func is the function object; im_class is the class of im_self (for bound methods) or the class that asked for the method (for unbound methods).  In Python 3, these special method attributes have been renamed to follow the naming conventions of other attributes.
-
                                                    skip over this table
-
+
                                                    Special method attributes
                                                    
+
                                                    In Python 2, class methods can reference the class object they are defined in, as well as the method object itself.  im_self is the class instance object; the class im_func is the function object; im_class is the class of im_self (for bound methods) or the class that asked for the method (for unbound methods). In Python 3, these special method attributes have been renamed to follow the naming conventions of other attributes.
+
                                                    skip over this table
+
                                                    
@@ -920,11 +919,11 @@ except:
 
                                                    
 
                                                    Notes
 Python 2
 Python 3aClassInstance.aClassMethod.im_class
 aClassInstance.aClassMethod.self.__class__
                                                    
 
                                                    
-
                                                    
-
                                                    __nonzero__ special class attribute
                                                    
-
                                                    In Python 2, you could build your own classes that could be used in a boolean context.  For example, you could instantiate the class and then use the instance in an if statement.  To do this, you defined a special __nonzero__() method which returned True or False, and it was called whenever the instance was used in a boolean context.  In Python 3, you can still do this, but the name of the method has changed to __bool__().
-
                                                    skip over this table
-
+
                                                    
+
                                                    __nonzero__ special class attribute
                                                    
+
                                                    In Python 2, you could build your own classes that could be used in a boolean context. For example, you could instantiate the class and then use the instance in an if statement. To do this, you defined a special __nonzero__() method which returned True or False, and it was called whenever the instance was used in a boolean context. In Python 3, you can still do this, but the name of the method has changed to __bool__().
+
                                                    skip over this table
+
                                                    
@@ -942,14 +941,14 @@ except:
         pass
                                                    
 
                                                    Notes
 Python 2
 Python 3
 no change
                                                    
 
                                                    
-
                                                      
+
                                                        
 
                                                      1. Instead of __nonzero__(), Python 3 calls the __bool__() method when evaluating an instance in a boolean context.
 
                                                      2. However, if you have a __nonzero__() method that takes arguments, the 2to3 tool will assume that you were using it for some other purpose, and it will not make any changes.
 
                                                      
-
                                                      Octal literals
                                                      
+
                                                      Octal literals
                                                      
 
                                                      The syntax for defining base 8 (octal) numbers has changed slightly between Python 2 and Python 3.
-
                                                      skip over this table
-
+
                                                      skip over this table
+
                                                      
@@ -958,11 +957,11 @@ except:
 
                                                      
 
                                                      Notes
 Python 2
 Python 3x = 0755
 x = 0o755
                                                      
 
                                                      
-
                                                      
-
                                                      sys.maxint
                                                      
-
                                                      Due to the integration of the long and int types, the sys.maxint constant is no longer accurate.  Because the value may still be useful in determining platform-specific capabilities, it has been retained but renamed as sys.maxsize.
-
                                                      skip over this table
-
+
                                                      
+
                                                      sys.maxint
                                                      
+
                                                      Due to the integration of the long and int types, the sys.maxint constant is no longer accurate. Because the value may still be useful in determining platform-specific capabilities, it has been retained but renamed as sys.maxsize.
+
                                                      skip over this table
+
                                                      
@@ -974,14 +973,14 @@ except:
 
                                                      
 
                                                      Notes
 Python 2
 Python 3a_function(sys.maxint)
 a_function(sys.maxsize)
                                                      
 
                                                      
-
                                                        
+
                                                          
 
                                                        1. maxint becomes maxsize.
 
                                                        2. Any usage of sys.maxint becomes sys.maxsize.
 
                                                        
-
                                                        callable() global function
                                                        
-
                                                        In Python 2, you could check whether an object was callable (like a function) with the global callable() function.  In Python 3, this global function has been eliminated.  To check whether an object is callable, check for the existence of the __call__() special method.
-
                                                        skip over this table
-
+
                                                        callable() global function
                                                        
+
                                                        In Python 2, you could check whether an object was callable (like a function) with the global callable() function. In Python 3, this global function has been eliminated. To check whether an object is callable, check for the existence of the __call__() special method.
+
                                                        skip over this table
+
                                                        
@@ -990,11 +989,11 @@ except:
 
                                                        
 
                                                        Notes
 Python 2
 Python 3callable(anything)
 hasattr(anything, "__call__")
                                                        
 
                                                        
-
                                                        
-
                                                        zip() global function
                                                        
-
                                                        In Python 2, the global zip() function took any number of sequences and returned a list of tuples.  The first tuple contained the first item from each sequence; the second tuple contained the second item from each sequence; and so on.  In Python 3, zip() returns an iterator instead of a list.
-
                                                        skip over this table
-
+
                                                        
+
                                                        zip() global function
                                                        
+
                                                        In Python 2, the global zip() function took any number of sequences and returned a list of tuples. The first tuple contained the first item from each sequence; the second tuple contained the second item from each sequence; and so on. In Python 3, zip() returns an iterator instead of a list.
+
                                                        skip over this table
+
                                                        
@@ -1006,14 +1005,14 @@ except:
 
                                                        
 
                                                        Notes
 Python 2
 Python 3d.join(zip(a, b, c))
 no change
                                                        
 
                                                        
-
                                                          
+
                                                            
 
                                                          1. In the simplest form, you can get the old behavior of the zip() function by wrapping the return value in a call to list(), which will run through the iterator that zip() returns and return a real list of the results.
-
                                                          2. In contexts that already iterate through all the items of a sequence (such as this call to the join() method), the iterator that zip() returns will work just fine.  The 2to3 script is smart enough to detect these cases and make no change to your code.
+
                                                          3. In contexts that already iterate through all the items of a sequence (such as this call to the join() method), the iterator that zip() returns will work just fine. The 2to3 script is smart enough to detect these cases and make no change to your code.
 
                                                          
-
                                                          StandardError exception
                                                          
-
                                                          In Python 2, StandardError was the base class for all built-in exceptions other than StopIteration, GeneratorExit, KeyboardInterrupt, and SystemExit.  In Python 3, StandardError has been eliminated; use Exception instead.
-
                                                          skip over this table
-
+
                                                          StandardError exception
                                                          
+
                                                          In Python 2, StandardError was the base class for all built-in exceptions other than StopIteration, GeneratorExit, KeyboardInterrupt, and SystemExit. In Python 3, StandardError has been eliminated; use Exception instead.
+
                                                          skip over this table
+
                                                          
@@ -1025,11 +1024,11 @@ except:
 
                                                          
 
                                                          Notes
 Python 2
 Python 3x = StandardError(a, b, c)
 x = Exception(a, b, c)
                                                          
 
                                                          
-
                                                          
-
                                                          types module constants
                                                          
-
                                                          The types module contains a variety of constants to help you determine the type of an object.  In Python 2, it contained constants for all primitive types like dict and int.  In Python 3, these constants have been eliminated; just use the primitive type name instead.
-
                                                          skip over this table
-
+
                                                          
+
                                                          types module constants
                                                          
+
                                                          The types module contains a variety of constants to help you determine the type of an object. In Python 2, it contained constants for all primitive types like dict and int. In Python 3, these constants have been eliminated; just use the primitive type name instead.
+
                                                          skip over this table
+
                                                          
@@ -1053,11 +1052,11 @@ except:
 
                                                          
 
                                                          Notes
 Python 2
 Python 3types.NoneType
 type(None)
                                                          
 
                                                          
-
                                                          
-
                                                          isinstance() global function (3.1+)
                                                          
-
                                                          The isinstance() function checks whether an object is an instance of a particular class or type.  In Python 2, you could pass a tuple of types, and isinstance() would return True if the object was any of those types.  In Python 3, you can still do this, but passing the same type twice is deprecated.
-
                                                          skip over this table
-
+
                                                          
+
                                                          isinstance() global function (3.1+)
                                                          
+
                                                          The isinstance() function checks whether an object is an instance of a particular class or type. In Python 2, you could pass a tuple of types, and isinstance() would return True if the object was any of those types. In Python 3, you can still do this, but passing the same type twice is deprecated.
+
                                                          skip over this table
+
                                                          
@@ -1066,13 +1065,13 @@ except:
 
                                                          
 
                                                          Notes
 Python 2
 Python 3isinstance(x, (int, float, int))
 isinstance(x, (int, float))
                                                          
 
                                                          
-
                                                          
-
                                                          ☞The version of 2to3 that shipped with Python 3.0 would not fix these cases of isinstance() automatically.  The fix first appeared in the 2to3 script that shipped with Python 3.1.
+
                                                          
+
                                                          ☞The version of 2to3 that shipped with Python 3.0 would not fix these cases of isinstance() automatically. The fix first appeared in the 2to3 script that shipped with Python 3.1.
 
                                                          
-
                                                          basestring datatype
                                                          
-
                                                          Python 2 had two string types: Unicode and non-Unicode.  But there was also another type, basestring.  It was an abstract type, a superclass for both the str and unicode types.  It couldn't be called or instantiated directly, but you could pass it to the global isinstance() function to check whether an object was either a Unicode or non-Unicode string.  In Python 3, there is only one string type, so basestring has no reason to exist.
-
                                                          skip over this table
-
+
                                                          basestring datatype
                                                          
+
                                                          Python 2 had two string types: Unicode and non-Unicode. But there was also another type, basestring. It was an abstract type, a superclass for both the str and unicode types. It couldn't be called or instantiated directly, but you could pass it to the global isinstance() function to check whether an object was either a Unicode or non-Unicode string. In Python 3, there is only one string type, so basestring has no reason to exist.
+
                                                          skip over this table
+
                                                          
@@ -1081,10 +1080,10 @@ except:
 
                                                          
 
                                                          Notes
 Python 2
 Python 3isinstance(x, basestring)
 isinstance(x, str)
                                                          
 
                                                          
-
                                                          
-
                                                          itertools module
                                                          
-
                                                          Python 2.3 introduced the itertools module, which defined variants of the global zip(), map(), and filter() functions that returned iterators instead of lists.  In Python 3, those global functions return iterators, so those functions in the itertools module have been eliminated.
-
+
                                                          
+
                                                          itertools module
                                                          
+
                                                          Python 2.3 introduced the itertools module, which defined variants of the global zip(), map(), and filter() functions that returned iterators instead of lists. In Python 3, those global functions return iterators, so those functions in the itertools module have been eliminated.
+
                                                          
@@ -1102,16 +1101,16 @@ except:
 
                                                          
 
                                                          Notes
 Python 2
 Python 3from itertools import imap, izip, foo
 from itertools import foo
                                                          
 
                                                          
-
                                                            
+
                                                              
 
                                                            1. Instead of itertools.izip(), just use the global zip() function.
 
                                                            2. Instead of itertools.imap(), just use map().
 
                                                            3. itertools.ifilter() becomes filter().
-
                                                            4. The itertools module still exists in Python 3, it just doesn't have the functions that have migrated to the global namespace.  The 2to3 script is smart enough to remove the specific imports that no longer exist, while leaving other imports intact.
+
                                                            5. The itertools module still exists in Python 3, it just doesn't have the functions that have migrated to the global namespace. The 2to3 script is smart enough to remove the specific imports that no longer exist, while leaving other imports intact.
 
                                                            
-
                                                            sys.exc_type, sys.exc_value, sys.exc_traceback
                                                            
-
                                                            Python 2 had three variables in the sys module that you could access while an exception was being handled: sys.exc_type, sys.exc_value, sys.exc_traceback.  (Actually, these date all the way back to Python 1.)  Ever since Python 1.5, these variables have been deprecated in favor of sys.exc_info, which is a tuple that contains all three values.  In Python 3, these individual variables have finally gone away; you must use sys.exc_info.
-
                                                            skip over this table
-
+
                                                            sys.exc_type, sys.exc_value, sys.exc_traceback
                                                            
+
                                                            Python 2 had three variables in the sys module that you could access while an exception was being handled: sys.exc_type, sys.exc_value, sys.exc_traceback. (Actually, these date all the way back to Python 1.)  Ever since Python 1.5, these variables have been deprecated in favor of sys.exc_info, which is a tuple that contains all three values. In Python 3, these individual variables have finally gone away; you must use sys.exc_info.
+
                                                            skip over this table
+
                                                            
@@ -1126,11 +1125,11 @@ except:
 
                                                            
 
                                                            Notes
 Python 2
 Python 3sys.exc_traceback
 sys.exc_info()[2]
                                                            
 
                                                            
-
                                                            
-
                                                            List comprehensions over tuples
                                                            
-
                                                            In Python 2, if you wanted to code a list comprehension that iterated over a tuple, you did not need to put parentheses around the tuple values.  In Python 3, explicit parentheses are required.
-
                                                            skip over this table
-
+
                                                            
+
                                                            List comprehensions over tuples
                                                            
+
                                                            In Python 2, if you wanted to code a list comprehension that iterated over a tuple, you did not need to put parentheses around the tuple values. In Python 3, explicit parentheses are required.
+
                                                            skip over this table
+
                                                            
@@ -1139,11 +1138,11 @@ except:
 
                                                            
 
                                                            Notes
 Python 2
 Python 3[i for i in 1, 2]
 [i for i in (1, 2)]
                                                            
 
                                                            
-
                                                            
-
                                                            os.getcwdu() function
                                                            
-
                                                            Python 2 had a function named os.getcwd(), which returned the current working directory as a (non-Unicode) string.  Because modern file systems can handle directory names in any character encoding, Python 2.3 introduced os.getcwdu().  The os.getcwdu() function returned the current working directory as a Unicode string.  In Python 3, there is only one string type (Unicode), so os.getcwd() is all you need.
-
                                                            skip over this table
-
+
                                                            
+
                                                            os.getcwdu() function
                                                            
+
                                                            Python 2 had a function named os.getcwd(), which returned the current working directory as a (non-Unicode) string. Because modern file systems can handle directory names in any character encoding, Python 2.3 introduced os.getcwdu(). The os.getcwdu() function returned the current working directory as a Unicode string. In Python 3, there is only one string type (Unicode), so os.getcwd() is all you need.
+
                                                            skip over this table
+
                                                            
@@ -1152,11 +1151,11 @@ except:
 
                                                            
 
                                                            Notes
 Python 2
 Python 3os.getcwdu()
 os.getcwd()
                                                            
 
                                                            
-
                                                            
-
                                                            Metaclasses
                                                            
-
                                                            In Python 2, you could create metaclasses either by defining the metaclass argument in the class declaration, or by defining a special class-level __metaclass__ attribute.  In Python 3, the class-level attribute has been eliminated.
-
                                                            skip over this table
-
+
                                                            
+
                                                            Metaclasses
                                                            
+
                                                            In Python 2, you could create metaclasses either by defining the metaclass argument in the class declaration, or by defining a special class-level __metaclass__ attribute. In Python 3, the class-level attribute has been eliminated.
+
                                                            skip over this table
+
                                                            
@@ -1176,20 +1175,20 @@ except:
 
                                                            
 
                                                            Notes
 Python 2
 Python 3
                                                            class C(Whipper, Beater, metaclass=PapayaMeta):
     pass
                                                            
 
                                                            
-
                                                              
+
                                                                
 
                                                              1. Declaring the metaclass in the class declaration worked in Python 2, and it still works the same in Python 3.
 
                                                              2. Declaring the metaclass in a class attribute worked in Python 2, but doesn't work in Python 3.
 
                                                              3. The 2to3 script is smart enough to construct a valid class declaration, even if the class is inherited from one or more base classes.
 
                                                              
-
                                                              Matters of style
                                                              
-
                                                              The rest of the “fixes” listed here aren't really fixes per se.  That is, the things they change are matters of style, not substance.  They work just as well in Python 3 as they do in Python 2, but the developers of Python have a vested interest in making Python code as uniform as possible.  To that end, there is an official Python style guide which outlines — in excruciating detail — all sorts of nitpicky details that you almost certainly don't care about.  And given that 2to3 provides such a great infrastructure for converting Python code from one thing to another, the authors took it upon themselves to add a few optional features to improve the readability of your Python programs.
-
                                                              set() literals (explicit)
                                                              
-
                                                              In Python 2, the only way to define a literal set in your code was to call set(a_sequence).  This still works in Python 3, but a clearer way of doing it is to use the new set literal notation: curly braces.  (Dictionaries are also defined with curly braces, which makes sense once you think about it, because dictionaries are just sets of key-value pairs.)
-
                                                              
-
                                                              ☞The 2to3 script will not fix set() literals by default.  To enable this fix, specify -f set_literal on the command line when you call 2to3.
+
                                                              Matters of style
                                                              
+
                                                              The rest of the “fixes” listed here aren't really fixes per se. That is, the things they change are matters of style, not substance. They work just as well in Python 3 as they do in Python 2, but the developers of Python have a vested interest in making Python code as uniform as possible. To that end, there is an official Python style guide which outlines — in excruciating detail — all sorts of nitpicky details that you almost certainly don't care about. And given that 2to3 provides such a great infrastructure for converting Python code from one thing to another, the authors took it upon themselves to add a few optional features to improve the readability of your Python programs.
+
                                                              set() literals (explicit)
                                                              
+
                                                              In Python 2, the only way to define a literal set in your code was to call set(a_sequence). This still works in Python 3, but a clearer way of doing it is to use the new set literal notation: curly braces. (Dictionaries are also defined with curly braces, which makes sense once you think about it, because dictionaries are just sets of key-value pairs.)
+
                                                              
+
                                                              ☞The 2to3 script will not fix set() literals by default. To enable this fix, specify -f set_literal on the command line when you call 2to3.
 
                                                              
-
                                                              skip over this table
-
+
                                                              skip over this table
+
                                                              
@@ -1204,14 +1203,14 @@ except:
 
                                                              
 
                                                              Notes
 Before
 Afterset([i for i in a_sequence])
 {i for i in a_sequence}
                                                              
 
                                                              
-
                                                              
-
                                                              buffer() global function (explicit)
                                                              
-
                                                              Python objects implemented in C can export a “buffer interface,” which is a block of memory that is directly readable and writeable without copying.  (That is exactly as powerful and scary as it sounds.)  In Python 3, buffer() has been renamed to memoryview().  (It's a little more complicated than that, but you can almost certainly ignore the differences.)
-
                                                              
-
                                                              ☞The 2to3 script will not fix the buffer() function by default.  To enable this fix, specify -f buffer on the command line when you call 2to3.
+
                                                              
+
                                                              buffer() global function (explicit)
                                                              
+
                                                              Python objects implemented in C can export a “buffer interface,” which is a block of memory that is directly readable and writeable without copying. (That is exactly as powerful and scary as it sounds.)  In Python 3, buffer() has been renamed to memoryview(). (It's a little more complicated than that, but you can almost certainly ignore the differences.)
+
                                                              
+
                                                              ☞The 2to3 script will not fix the buffer() function by default. To enable this fix, specify -f buffer on the command line when you call 2to3.
 
                                                              
-
                                                              skip over this table
-
+
                                                              skip over this table
+
                                                              
@@ -1220,14 +1219,14 @@ except:
 
                                                              
 
                                                              Notes
 Before
 Afterx = buffer(y)
 x = memoryview(y)
                                                              
 
                                                              
-
                                                              
-
                                                              Whitespace around commas (explicit)
                                                              
-
                                                              Despite being draconian about whitespace for indenting and outdenting, Python is actually quite liberal about whitespace in other areas.  Within lists, tuples, sets, and dictionaries, whitespace can appear before and after commas with no ill effects.  However, the Python style guide states that commas should be preceded by zero spaces and followed by one.  Although this is purely an aesthetic issue (the code works either way, in both Python 2 and Python 3), the 2to3 script can optionally fix this for you.
-
                                                              
-
                                                              ☞The 2to3 script will not fix whitespace around commas by default.  To enable this fix, specify -f wscomma on the command line when you call 2to3.
+
                                                              
+
                                                              Whitespace around commas (explicit)
                                                              
+
                                                              Despite being draconian about whitespace for indenting and outdenting, Python is actually quite liberal about whitespace in other areas. Within lists, tuples, sets, and dictionaries, whitespace can appear before and after commas with no ill effects. However, the Python style guide states that commas should be preceded by zero spaces and followed by one. Although this is purely an aesthetic issue (the code works either way, in both Python 2 and Python 3), the 2to3 script can optionally fix this for you.
+
                                                              
+
                                                              ☞The 2to3 script will not fix whitespace around commas by default. To enable this fix, specify -f wscomma on the command line when you call 2to3.
 
                                                              
-
                                                              skip over this table
-
+
                                                              skip over this table
+
                                                              
@@ -1239,14 +1238,14 @@ except:
 
                                                              
 
                                                              Notes
 Before
 After{a :b}
 {a: b}
                                                              
 
                                                              
-
                                                              
-
                                                              Common idioms (explicit)
                                                              
-
                                                              There were a number of common idioms built up in the Python community.  Some, like the while 1: loop, date back to Python 1.  (Python didn't have a true boolean type until version 2.3, so developers used 1 and 0 instead.)  Modern Python programmers should train their brains to use modern versions of these idioms instead.
-
                                                              
-
                                                              ☞The 2to3 script will not fix common idioms by default.  To enable this fix, specify -f idioms on the command line when you call 2to3.
+
                                                              
+
                                                              Common idioms (explicit)
                                                              
+
                                                              There were a number of common idioms built up in the Python community. Some, like the while 1: loop, date back to Python 1. (Python didn't have a true boolean type until version 2.3, so developers used 1 and 0 instead.)  Modern Python programmers should train their brains to use modern versions of these idioms instead.
+
                                                              
+
                                                              ☞The 2to3 script will not fix common idioms by default. To enable this fix, specify -f idioms on the command line when you call 2to3.
 
                                                              
-
                                                              skip over this table
-
+
                                                              skip over this table
+
                                                              
@@ -1269,10 +1268,8 @@ do_stuff(a_list)
                                                              
 
                                                              Notes
 Before
 After
 
                                                              a_list = sorted(a_sequence)
 do_stuff(a_list)
                                                              
 
                                                              
-
                                                              
+
                                                              
 
                                                              FIXME: once the rest of the book is written, this appendix should contain copious links back to any chapter or section that touches on these features.
-
                                                              © 2001-4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
-
-
-
-
+
                                                              © 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
+
+
diff --git a/publish b/publish
index 7ac7a20..faa3551 100644
--- a/publish
+++ b/publish
@@ -1,13 +1,29 @@
 #!/bin/sh
 
+set -x
+
+# make build directory and copy original files there for preflighting
 rm -rf build
 mkdir build
-cp *.html *.py *.txt .htaccess build/
+cp *.html *.py *.txt .htaccess *.js *.css build/
+
+# replace local jquery reference with Google API loader
+sed -i -e "s|jquery\.hs|http://www.google.com/jsapi|g" build/*.html
+sed -i -e "s|//google\.|google.|g" build/dip3.js
+sed -i -e "s|//}.; /\* google\..*|});|g" build/dip3.js
+
+# minimize JS and CSS
 revision=`hg log|grep changeset|cut -d":" -f3|head -1`
-java -jar yuicompressor-2.4.2.jar dip3.js > build/dip3.$revision.min.js
-java -jar yuicompressor-2.4.2.jar dip3.css > build/dip3.$revision.min.css
+java -jar yuicompressor-2.4.2.jar build/dip3.js > build/dip3.$revision.min.js
+java -jar yuicompressor-2.4.2.jar build/dip3.css > build/dip3.$revision.min.css
+#rm build/dip3.js
+#rm build/dip3.css
 sed -i -e "s|dip3\.js|http://wearehugh.com/dip3/dip3.${revision}.min.js|g" build/*.html
 sed -i -e "s|dip3\.css|http://wearehugh.com/dip3/dip3.${revision}.min.css|g" build/*.html
+
+# set file permissions for public consumption
 chmod 644 build/*.html build/*.css build/*.js build/*.py build/*.txt build/.htaccess
-rsync -essh -avzP --delete --delete-after build/*.min.css build/*.min.js diveintomark.org:~/web/wearehugh.com/dip3/
-rsync -essh -avzP build/*.html build/*.py build/*.txt build/.htaccess diveintomark.org:~/web/diveintopython3.org/
+
+# and push to production
+#rsync -essh -avzP --delete --delete-after build/*.min.css build/*.min.js diveintomark.org:~/web/wearehugh.com/dip3/
+#rsync -essh -avzP build/*.html build/*.py build/*.txt build/.htaccess diveintomark.org:~/web/diveintopython3.org/
diff --git a/table-of-contents.html b/table-of-contents.html
index c32050b..c23add3 100644
--- a/table-of-contents.html
+++ b/table-of-contents.html
@@ -1,12 +1,12 @@
 
-
+
 
-
+
 Table of contents - Dive Into Python 3
-
-
-
-
 
-
-
                                                              
-
                                                              You are here: Home ‣ Dive Into Python 3 ‣
+
                                                              
+
                                                              You are here: Home ‣ Dive Into Python 3 ‣
 
                                                              Table of contents
                                                              
-
                                                                
+
                                                                  
 
                                                                1. Installing Python
   
                                                                    
   
                                                                  1. Python on Windows
@@ -27,49 +26,49 @@ ul li ol{margin:0;padding:0 0 0 2.5em}
   
                                                                  2. Python from source
   
                                                                  3. The interactive shell
   
                                                                  
-
                                                                2. Your first Python program
+
                                                                3. Your first Python program
   
                                                                    
-  
                                                                  1. Diving in
-  
                                                                  2. Declaring functions
-  
                                                                  3. Writing readable code
+  
                                                                  4. Diving in
+  
                                                                  5. Declaring functions
+  
                                                                  6. Writing readable code
   
                                                                      
-  
                                                                    1. Docstrings
-  
                                                                    2. Function annotations
-  
                                                                    3. Style conventions
+  
                                                                    4. Docstrings
+  
                                                                    5. Function annotations
+  
                                                                    6. Style conventions
   
                                                                    
-  
                                                                  7. Everything is an object
+  
                                                                  8. Everything is an object
   
                                                                      
-  
                                                                    1. The import search path
-  
                                                                    2. What's an object?
+  
                                                                    3. The import search path
+  
                                                                    4. What's an object?
   
                                                                    
-  
                                                                  9. Indenting code
-  
                                                                  10. Running scripts
-  
                                                                  11. Further reading
+  
                                                                  12. Indenting code
+  
                                                                  13. Running scripts
+  
                                                                  14. Further reading
   
                                                                  
-
                                                                4. Native Python datatypes
+
                                                                5. Native Python datatypes
   
                                                                    
-  
                                                                  1. Diving in
-  
                                                                  2. Booleans
-  
                                                                  3. Numbers
+  
                                                                  4. Diving in
+  
                                                                  5. Booleans
+  
                                                                  6. Numbers
 
-  
                                                                  7. Lists
-  
                                                                  8. Sets
-  
                                                                  9. Dictionaries
-  
                                                                  10. None
-  
                                                                  11. Further reading
+  
                                                                  12. Lists
+  
                                                                  13. Sets
+  
                                                                  14. Dictionaries
+  
                                                                  15. None
+  
                                                                  16. Further reading
   
                                                                  
 
                                                                6. Strings
   
                                                                    
-  
                                                                  1. There ain't no such thing as "plain text"
+  
                                                                  2. There ain't no such thing as plain text
     
                                                                      
     
                                                                    1. A brief history of character encoding
     
                                                                    2. What's a character?
@@ -112,7 +111,7 @@ ul li ol{margin:0;padding:0 0 0 2.5em}
   
                                                                    3. ...stuff about decorators...
   
                                                                    4. ...stuff about importing modules...
     
                                                                        
-    
                                                                      1. ...mention why "from module import *" is only allowed at module level
+    
                                                                      2. ...mention why from module import * is only allowed at module level
     
                                                                      
   
                                                                    
 
                                                                  3. Exceptions
@@ -253,7 +252,7 @@ ul li ol{margin:0;padding:0 0 0 2.5em}
   
                                                                  
 
                                                                7. Creating graphics with the Python Imaging Library
   
                                                                    
-  
                                                                  1. ...will likely get ported in time...
+  
                                                                  2. ...will likely get ported in time...
   
                                                                  
 
                                                                8. Where to go from here (tentative because most of these have not been ported to Python 3 yet)
   
                                                                    
@@ -267,93 +266,93 @@ ul li ol{margin:0;padding:0 0 0 2.5em}
   
                                                                  1. PyPy
   
                                                                  2. Stackless Python
   
                                                                  
-
                                                                9. Case study: porting chardet to Python 3
+
                                                                10. Case study: porting chardet to Python 3
   
                                                                    
-  
                                                                  1. Introducing chardet: a mini-FAQ
+  
                                                                  2. Introducing chardet: a mini-FAQ
     
                                                                      
-    
                                                                    1. What is character encoding auto-detection?
-    
                                                                    2. Isn't that impossible?
-    
                                                                    3. Who wrote this detection algorithm?
-    
                                                                    4. Yippie!  Screw the standards, I'll just auto-detect everything!
-    
                                                                    5. Why bother with auto-detection if it's slow, inaccurate, and non-standard?
+    
                                                                    6. What is character encoding auto-detection?
+    
                                                                    7. Isn't that impossible?
+    
                                                                    8. Who wrote this detection algorithm?
+    
                                                                    9. Yippie!  Screw the standards, I'll just auto-detect everything!
+    
                                                                    10. Why bother with auto-detection if it's slow, inaccurate, and non-standard?
     
                                                                    
-  
                                                                  3. Diving in
+  
                                                                  4. Diving in
     
                                                                      
-    
                                                                    1. UTF-n with a BOM
-    
                                                                    2. Escaped encodings
-    
                                                                    3. Multi-byte encodings
-    
                                                                    4. Single-byte encodings
-    
                                                                    5. windows-1252
+    
                                                                    6. UTF-n with a BOM
+    
                                                                    7. Escaped encodings
+    
                                                                    8. Multi-byte encodings
+    
                                                                    9. Single-byte encodings
+    
                                                                    10. windows-1252
     
                                                                    
-  
                                                                  5. Running 2to3
-  
                                                                  6. Fixing what 2to3 can't
+  
                                                                  7. Running 2to3
+  
                                                                  8. Fixing what 2to3 can't
     
                                                                      
-    
                                                                    1. False is invalid syntax
-    
                                                                    2. No module named constants
-    
                                                                    3. Name 'file' is not defined
-    
                                                                    4. Can't use a string pattern on a bytes-like object
-    
                                                                    5. Can't convert 'bytes' object to str implicitly
+    
                                                                    6. False is invalid syntax
+    
                                                                    7. No module named constants
+    
                                                                    8. Name 'file' is not defined
+    
                                                                    9. Can't use a string pattern on a bytes-like object
+    
                                                                    10. Can't convert 'bytes' object to str implicitly
     
                                                                    
   
                                                                  
 
                                                                
 
@@ -367,6 +366,4 @@ ul li ol{margin:0;padding:0 0 0 2.5em}
   
                                                              1. Dictionary comprehensions
   
                                                              2. Views (several dictionary methods return them, they're dynamic, update when the dictionary changes, etc.)
 
-
                                                                © 2001-4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
-
-
+
                                                                © 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
diff --git a/your-first-python-program.html b/your-first-python-program.html
index 2f4205c..7466e1b 100644
--- a/your-first-python-program.html
+++ b/your-first-python-program.html
@@ -1,48 +1,47 @@
 
-
+
 
-
+
 Your first Python program - Dive into Python 3
-
-
-
-
 
-
-
                                                                skip to main content
-
                                                                
-
                                                                You are here: Home ‣ Dive Into Python 3 ‣
+
                                                                skip to main content
+
                                                                
+
                                                                You are here: Home ‣ Dive Into Python 3 ‣
 
                                                                Your first Python program
                                                                
-
                                                                
-
                                                                ❝ Don’t bury your burden in saintly silence.  You have a problem?  Great.  Rejoice, dive in, and investigate. ❞
                                                                — Ven. Henepola Gunararatana
+
                                                                
+
                                                                ❝ Don’t bury your burden in saintly silence. You have a problem?  Great. Rejoice, dive in, and investigate. ❞
                                                                — Ven. Henepola Gunararatana
 
                                                                
 
                                                                  
-
                                                                1. Diving in
-
                                                                2. Declaring functions
+
                                                                3. Diving in
+
                                                                4. Declaring functions
 
                                                                    
-
                                                                  1. How Python's datatypes compare to other programming languages
+
                                                                  2. How Python's datatypes compare to other programming languages
 
                                                                  
-
                                                                5. Writing readable code
+
                                                                6. Writing readable code
 
                                                                    
-
                                                                  1. Docstrings
-
                                                                  2. Function annotations
-
                                                                  3. Style conventions
+
                                                                  4. Docstrings
+
                                                                  5. Function annotations
+
                                                                  6. Style conventions
 
                                                                  
-
                                                                7. Everything is an object
+
                                                                8. Everything is an object
 
                                                                    
-
                                                                  1. The import search path
-
                                                                  2. What's an object?
+
                                                                  3. The import search path
+
                                                                  4. What's an object?
 
                                                                  
-
                                                                9. Indenting code
-
                                                                10. Running scripts
-
                                                                11. Further reading
+
                                                                12. Indenting code
+
                                                                13. Running scripts
+
                                                                14. Further reading
 
                                                                
-
                                                                Diving in
                                                                
-
                                                                You know how other books go on and on about programming fundamentals and finally work up to building something useful?  Let's skip all that.  Here is a complete, working Python program.  It probably makes absolutely no sense to you.  Don't worry about that, because you're going to dissect it line by line.  But read through it first and see what, if anything, you can make of it.
+
                                                                Diving in
                                                                
+
                                                                You know how other books go on and on about programming fundamentals and finally work up to building something useful?  Let's skip all that. Here is a complete, working Python program. It probably makes absolutely no sense to you. Don't worry about that, because you're going to dissect it line by line. But read through it first and see what, if anything, you can make of it.
 
-
                                                                [download]
                                                                
+
                                                                [download]
                                                                
 
                                                                SUFFIXES = {1000: ('KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'),
             1024: ('KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB')}
 
@@ -71,54 +70,54 @@ def approximate_size(size, a_kilobyte_is_1024_bytes=True):
 if __name__ == "__main__":
     print(approximate_size(1000000000000, False))
     print(approximate_size(1000000000000))
                                                                
-
                                                                Now let's run this program on the command line.  On Windows, it will look something like this:
-
                                                                c:\home\diveintopython3> c:\python30\python.exe humansize.py
+
                                                                Now let's run this program on the command line. On Windows, it will look something like this:
+
                                                                c:\home\diveintopython3> c:\python30\python.exe humansize.py
 1.0 TB
 931.3 GiB
                                                                
 
                                                                On Mac OS X or Linux, it would look something like this:
-
                                                                you@localhost:~$ python3 humansize.py
+
                                                                you@localhost:~$ python3 humansize.py
 1.0 TB
 931.3 GiB
                                                                
 
-
                                                                Declaring functions
                                                                
-
                                                                Python has functions like most other languages, but it does not have separate header files like C++ or interface/implementation sections like Pascal.  When you need a function, just declare it, like this:
+
                                                                Declaring functions
                                                                
+
                                                                Python has functions like most other languages, but it does not have separate header files like C++ or interface/implementation sections like Pascal. When you need a function, just declare it, like this:
 
                                                                def approximate_size(size, a_kilobyte_is_1024_bytes=True):
                                                                
-
                                                                The keyword def starts the function declaration, followed by the function name, followed by the arguments in parentheses.  Multiple arguments are separated with commas.
-
                                                                Also note that the function doesn't define a return datatype.  Python functions do not specify the datatype of their return value; they don't even specify whether or not they return a value.  (In fact, every Python function returns a value; if the function ever executes a return statement, it will return that value, otherwise it will return None, the Python null value.)
-
                                                                
-
                                                                ☞In some languages, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub.  There are no subroutines in Python.  Everything is a function, all functions return a value (even if it's None), and all functions start with def.
+
                                                                The keyword def starts the function declaration, followed by the function name, followed by the arguments in parentheses. Multiple arguments are separated with commas.
+
                                                                Also note that the function doesn't define a return datatype. Python functions do not specify the datatype of their return value; they don't even specify whether or not they return a value. (In fact, every Python function returns a value; if the function ever executes a return statement, it will return that value, otherwise it will return None, the Python null value.)
+
                                                                
+
                                                                ☞In some languages, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub. There are no subroutines in Python. Everything is a function, all functions return a value (even if it's None), and all functions start with def.
 
                                                                
-
                                                                The approximate_size function takes the two arguments — size and a_kilobyte_is_1024_bytes — but neither argument specifies a datatype.  (As you might guess from the =True syntax, the second argument is a boolean.  You'll learn what that syntax does in [FIXME xref-was-#apihelper].)  In Python, variables are never explicitly typed.  Python figures out what type a variable is and keeps track of it internally.
+
                                                                The approximate_size function takes the two arguments — size and a_kilobyte_is_1024_bytes — but neither argument specifies a datatype. (As you might guess from the =True syntax, the second argument is a boolean. You'll learn what that syntax does in [FIXME xref-was-#apihelper].)  In Python, variables are never explicitly typed. Python figures out what type a variable is and keeps track of it internally.
 
                                                                
-
                                                                ☞In Java and other statically-typed languages, you must specify the datatype of the function return value and each function argument.  In Python, you never explicitly specify the datatype of anything.  Based on what value you assign, Python keeps track of the datatype internally.
+
                                                                ☞In Java and other statically-typed languages, you must specify the datatype of the function return value and each function argument. In Python, you never explicitly specify the datatype of anything. Based on what value you assign, Python keeps track of the datatype internally.
 
                                                                
-
                                                                How Python's datatypes compare to other programming languages
                                                                
+
                                                                How Python's datatypes compare to other programming languages
                                                                
 
                                                                An erudite reader sent me this explanation of how Python compares to other programming languages:
 
                                                                
 
                                                                statically typed language
                                                                
-
                                                                A language in which types are fixed at compile time.  Most statically typed languages enforce this by requiring you to declare all variables with their datatypes before using them.  Java and C are statically typed languages.
+
                                                                A language in which types are fixed at compile time. Most statically typed languages enforce this by requiring you to declare all variables with their datatypes before using them. Java and C are statically typed languages.
 
                                                                
 
                                                                dynamically typed language
                                                                
-
                                                                A language in which types are discovered at execution time; the opposite of statically typed.  JavaScript and Python are dynamically typed, because they figure out what type a variable is when you first assign it a value.
+
                                                                A language in which types are discovered at execution time; the opposite of statically typed. JavaScript and Python are dynamically typed, because they figure out what type a variable is when you first assign it a value.
 
                                                                
 
                                                                strongly typed language
                                                                
-
                                                                A language in which types are always enforced.  Java and Python are strongly typed.  If you have an integer, you can't treat it like a string without explicitly converting it.
+
                                                                A language in which types are always enforced. Java and Python are strongly typed. If you have an integer, you can't treat it like a string without explicitly converting it.
 
                                                                
 
                                                                weakly typed language
                                                                
-
                                                                A language in which types are “automagically” coerced to other types as needed; the opposite of strongly typed.  PHP is weakly typed.  In PHP, you can concatenate the string '12' and the integer 3 to get the string '123', then treat that as the integer 123, all without any explicit conversion. [FIXME double-check this]
+
                                                                A language in which types are “automagically” coerced to other types as needed; the opposite of strongly typed. PHP is weakly typed. In PHP, you can concatenate the string '12' and the integer 3 to get the string '123', then treat that as the integer 123, all without any explicit conversion. [FIXME double-check this]
 
                                                                
 
                                                                
 
                                                                So Python is both dynamically typed (because it doesn't use explicit datatype declarations) and strongly typed (because once a variable has a datatype, it actually matters).
 
                                                                If you have experience in other programming languages, this table may help you visualize how Python compares to them:
-
+
                                                                
 
                                                                Statically typedDynamically typed
                                                                
 
                                                                Weakly typedC, Objective-CJavaScript, Perl 5, PHP
                                                                
 
                                                                Strongly typedPascal, JavaPython, Ruby
                                                                
 
                                                                
-
                                                                Writing readable code
                                                                
-
                                                                I won't bore you with a long finger-wagging speech about the importance of documenting your code.  Just know that code is written once but read many times, and the most important audience for your code is yourself, six months after writing it (i.e. after you've forgotten everything but need to fix something).  Python makes it easy to write readable code, so take advantage of it.  You'll thank me in six months.
-
                                                                Documentation strings
                                                                
-
                                                                You can document a Python function by giving it a documentation string (docstring for short).  In this program, the approximate_size function has a docstring:
+
                                                                Writing readable code
                                                                
+
                                                                I won't bore you with a long finger-wagging speech about the importance of documenting your code. Just know that code is written once but read many times, and the most important audience for your code is yourself, six months after writing it (i.e. after you've forgotten everything but need to fix something). Python makes it easy to write readable code, so take advantage of it. You'll thank me in six months.
+
                                                                Documentation strings
                                                                
+
                                                                You can document a Python function by giving it a documentation string (docstring for short). In this program, the approximate_size function has a docstring:
 
                                                                def approximate_size(size, a_kilobyte_is_1024_bytes=True):
     """Convert a file size to human-readable form.
 
@@ -130,26 +129,26 @@ if __name__ == "__main__":
     Returns: string
 
     """
                                                                
-
                                                                Triple quotes signify a multi-line string.  Everything between the start and end quotes is part of a single string, including carriage returns, leading white space, and other quote characters.  You can use them anywhere, but you'll see them most often used when defining a docstring.
+
                                                                Triple quotes signify a multi-line string. Everything between the start and end quotes is part of a single string, including carriage returns, leading white space, and other quote characters. You can use them anywhere, but you'll see them most often used when defining a docstring.
 
                                                                
 
                                                                ☞Triple quotes are also an easy way to define a string with both single and double quotes, like qq/.../ in Perl 5.
 
                                                                
-
                                                                Everything between the triple quotes is the function's docstring, which documents what the function does.  A docstring, if it exists, must be the first thing defined in a function (that is, on the next line after the function declaration).  You don't technically need to give your function a docstring, but you always should.  I know you've heard this in every programming class you've ever taken, but Python gives you an added incentive: the docstring is available at runtime as an attribute of the function.
-
                                                                
-
                                                                ☞Many Python IDEs use the docstring to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip.  This can be incredibly helpful, but it's only as good as the docstrings you write.
+
                                                                Everything between the triple quotes is the function's docstring, which documents what the function does. A docstring, if it exists, must be the first thing defined in a function (that is, on the next line after the function declaration). You don't technically need to give your function a docstring, but you always should. I know you've heard this in every programming class you've ever taken, but Python gives you an added incentive: the docstring is available at runtime as an attribute of the function.
+
                                                                
+
                                                                ☞Many Python IDEs use the docstring to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip. This can be incredibly helpful, but it's only as good as the docstrings you write.
 
                                                                
-
                                                                Function annotations
                                                                
+
                                                                Function annotations
                                                                
 
                                                                FIXME
-
                                                                Style conventions
                                                                
+
                                                                Style conventions
                                                                
 
                                                                FIXME
-
                                                                Everything is an object
                                                                
-
                                                                In case you missed it, I just said that Python functions have attributes, and that those attributes are available at runtime.  A function, like everything else in Python, is an object.
+
                                                                Everything is an object
                                                                
+
                                                                In case you missed it, I just said that Python functions have attributes, and that those attributes are available at runtime. A function, like everything else in Python, is an object.
 
                                                                Run the interactive Python shell and follow along:
-
                                                                ->>> import humansize                               ①
->>> print(humansize.approximate_size(4096, True))  ②
+
                                                                +>>> import humansize                               ①
+>>> print(humansize.approximate_size(4096, True))  ②
 4.0 KiB
->>> print(humansize.approximate_size.__doc__)      ③
+>>> print(humansize.approximate_size.__doc__)      ③
 Convert a file size to human-readable form.
 
     Keyword arguments:
@@ -161,34 +160,34 @@ if __name__ == "__main__":
 
 
                                                                
 
                                                                  
-
                                                                1. The first line imports the humansize program as a module -- a chunk of code that you can use interactively, or from a larger Python program.  (You'll see examples of multi-module Python programs in [FIXME xref].)  Once you import a module, you can reference any of its public functions, classes, or attributes.  Modules can do this to access functionality in other modules, and you can do it in the Python interactive shell too.  This is an important concept, and you'll see a lot more of it throughout this book.
-
                                                                2. When you want to use functions defined in imported modules, you need to include the module name.  So you can't just say approximate_size; it must be humansize.approximate_size.  If you've used classes in Java, this should feel vaguely familiar.
+
                                                                3. The first line imports the humansize program as a module -- a chunk of code that you can use interactively, or from a larger Python program. (You'll see examples of multi-module Python programs in [FIXME xref].)  Once you import a module, you can reference any of its public functions, classes, or attributes. Modules can do this to access functionality in other modules, and you can do it in the Python interactive shell too. This is an important concept, and you'll see a lot more of it throughout this book.
+
                                                                4. When you want to use functions defined in imported modules, you need to include the module name. So you can't just say approximate_size; it must be humansize.approximate_size. If you've used classes in Java, this should feel vaguely familiar.
 
                                                                5. Instead of calling the function as you would expect to, you asked for one of the function's attributes, __doc__.
 
                                                                
 
                                                                
-
                                                                ☞import in Python is like require in Perl.  Once you import a Python module, you access its functions with module.function; once you require a Perl module, you access its functions with module::function.
+
                                                                ☞import in Python is like require in Perl. Once you import a Python module, you access its functions with module.function; once you require a Perl module, you access its functions with module::function.
 
                                                                
-
                                                                The import search path
                                                                
-
                                                                Before this goes any further, I want to briefly mention the library search path.  Python looks in several places when you try to import a module.  Specifically, it looks in all the directories defined in sys.path.  This is just a list, and you can easily view it or modify it with standard list methods.  (You'll learn more about lists later in this chapter.)
-
                                                                ->>> import sys                       ①
->>> sys.path                         ②
+
                                                                The import search path
                                                                
+
                                                                Before this goes any further, I want to briefly mention the library search path. Python looks in several places when you try to import a module. Specifically, it looks in all the directories defined in sys.path. This is just a list, and you can easily view it or modify it with standard list methods. (You'll learn more about lists later in this chapter.)
+
                                                                +>>> import sys                       ①
+>>> sys.path                         ②
 ['', '/usr/lib/python30.zip', '/usr/lib/python3.0', '/usr/lib/python3.0/plat-linux2@EXTRAMACHDEPPATH@', '/usr/lib/python3.0/lib-dynload', '/usr/lib/python3.0/dist-packages', '/usr/local/lib/python3.0/dist-packages']
->>> sys                              ③
+>>> sys                              ③
 <module 'sys' (built-in)>
->>> sys.path.append('/my/new/path')  ④
                                                                
+>>> sys.path.append('/my/new/path')  ④
                                                                
 
                                                                  
 
                                                                1. Importing the sys module makes all of its functions and attributes available.
-
                                                                2. sys.path is a list of directory names that constitute the current search path.  (Yours will look different, depending on your operating system, what version of Python you're running, and where it was originally installed.)  Python will look through these directories (in this order) for a .py file whose name matches what you're trying to import.
-
                                                                3. Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files.  Some, like the sys module, are "built-in modules"; they are actually baked right into Python itself.  Built-in modules behave just like regular modules, but their Python source code is not available, because they are not written in Python!  (The sys module is written in C.)
-
                                                                4. You can add a new directory to Python's search path at runtime by appending the directory name to sys.path, and then Python will look in that directory as well, whenever you try to import a module.  The effect lasts as long as Python is running.  (You'll learn more about append() and other list methods in [FIXME xref-was-#datatypes].)
+
                                                                5. sys.path is a list of directory names that constitute the current search path. (Yours will look different, depending on your operating system, what version of Python you're running, and where it was originally installed.)  Python will look through these directories (in this order) for a .py file whose name matches what you're trying to import.
+
                                                                6. Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files. Some, like the sys module, are "built-in modules"; they are actually baked right into Python itself. Built-in modules behave just like regular modules, but their Python source code is not available, because they are not written in Python!  (The sys module is written in C.)
+
                                                                7. You can add a new directory to Python's search path at runtime by appending the directory name to sys.path, and then Python will look in that directory as well, whenever you try to import a module. The effect lasts as long as Python is running. (You'll learn more about append() and other list methods in [FIXME xref-was-#datatypes].)
 
                                                                
-
                                                                What's an object?
                                                                
-
                                                                Everything in Python is an object, and almost everything has attributes and methods.  All functions have a built-in attribute __doc__, which returns the docstring defined in the function's source code.  The sys module is an object which has (among other things) an attribute called path.  And so forth.
-
                                                                Still, this doesn't answer the more fundamental question: what is an object?  Different programming languages define “object” in different ways.  In some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable.  In Python, the definition is looser; some objects have neither attributes nor methods (more on this in [FIXME xref-was-#datatypes]), and not all objects are subclassable (more on this in [FIXME xref-was-#fileinfo]).  But everything is an object in the sense that it can be assigned to a variable or passed as an argument to a function (more in this in [FIXME xref-was-#apihelp]).
-
                                                                This is so important that I'm going to repeat it in case you missed it the first few times: everything in Python is an object.  Strings are objects.  Lists are objects.  Functions are objects.  Even modules are objects.
-
                                                                Indenting code
                                                                
-
                                                                Python functions have no explicit begin or end, and no curly braces to mark where the function code starts and stops.  The only delimiter is a colon (:) and the indentation of the code itself.
+
                                                                What's an object?
                                                                
+
                                                                Everything in Python is an object, and almost everything has attributes and methods. All functions have a built-in attribute __doc__, which returns the docstring defined in the function's source code. The sys module is an object which has (among other things) an attribute called path. And so forth.
+
                                                                Still, this doesn't answer the more fundamental question: what is an object?  Different programming languages define “object” in different ways. In some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable. In Python, the definition is looser; some objects have neither attributes nor methods (more on this in [FIXME xref-was-#datatypes]), and not all objects are subclassable (more on this in [FIXME xref-was-#fileinfo]). But everything is an object in the sense that it can be assigned to a variable or passed as an argument to a function (more in this in [FIXME xref-was-#apihelp]).
+
                                                                This is so important that I'm going to repeat it in case you missed it the first few times: everything in Python is an object. Strings are objects. Lists are objects. Functions are objects. Even modules are objects.
+
                                                                Indenting code
                                                                
+
                                                                Python functions have no explicit begin or end, and no curly braces to mark where the function code starts and stops. The only delimiter is a colon (:) and the indentation of the code itself.
 
                                                                
 def approximate_size(size, a_kilobyte_is_1024_bytes=True):  ①
     if size < 0:                                            ②
@@ -202,42 +201,40 @@ if __name__ == "__main__":
 
     raise ValueError('number too large')
                                                                
 
                                                                  
-
                                                                1. Code blocks are defined by their indentation.  By "code block," I mean functions, if statements, for loops, while loops, and so forth.  Indenting starts a block and unindenting ends it.  There are no explicit braces, brackets, or keywords.  This means that whitespace is significant, and must be consistent.  In this example, the function code is indented four spaces.  It doesn't need to be four spaces, it just needs to be consistent.  The first line that is not indented marks the end of the function.
-
                                                                2. In Python, an if statement is followed by a code block.  If the if expression evaluates to true, the indented block is executed, otherwise it falls to the else block (if any).  (Note the lack of parentheses around the expression.)
-
                                                                3. This line is inside the if code block.  This raise statement will raise an exception (of type ValueError), but only if size < 0.
-
                                                                4. This is not the end of the function.  Completely blank lines don't count.  The function continues on the next line.
-
                                                                5. The for loop also marks the start of a code block.  Code blocks can contain multiple lines, as long as they are all indented the same amount.  This for loop has three lines of code in it.  There is no other special syntax for multi-line code blocks.  Just indent and get on with your life.
+
                                                                6. Code blocks are defined by their indentation. By "code block," I mean functions, if statements, for loops, while loops, and so forth. Indenting starts a block and unindenting ends it. There are no explicit braces, brackets, or keywords. This means that whitespace is significant, and must be consistent. In this example, the function code is indented four spaces. It doesn't need to be four spaces, it just needs to be consistent. The first line that is not indented marks the end of the function.
+
                                                                7. In Python, an if statement is followed by a code block. If the if expression evaluates to true, the indented block is executed, otherwise it falls to the else block (if any). (Note the lack of parentheses around the expression.)
+
                                                                8. This line is inside the if code block. This raise statement will raise an exception (of type ValueError), but only if size < 0.
+
                                                                9. This is not the end of the function. Completely blank lines don't count. The function continues on the next line.
+
                                                                10. The for loop also marks the start of a code block. Code blocks can contain multiple lines, as long as they are all indented the same amount. This for loop has three lines of code in it. There is no other special syntax for multi-line code blocks. Just indent and get on with your life.
 
                                                                
-
                                                                After some initial protests and several snide analogies to Fortran, you will make peace with this and start seeing its benefits.  One major benefit is that all Python programs look similar, since indentation is a language requirement and not a matter of style.  This makes it easier to read and understand other people's Python code.
+
                                                                After some initial protests and several snide analogies to Fortran, you will make peace with this and start seeing its benefits. One major benefit is that all Python programs look similar, since indentation is a language requirement and not a matter of style. This makes it easier to read and understand other people's Python code.
 
                                                                
-
                                                                ☞Python uses carriage returns to separate statements and a colon and indentation to separate code blocks.  C++ and Java use semicolons to separate statements and curly braces to separate code blocks.
+
                                                                ☞Python uses carriage returns to separate statements and a colon and indentation to separate code blocks. C++ and Java use semicolons to separate statements and curly braces to separate code blocks.
 
                                                                
-
                                                                Running scripts
                                                                
-
                                                                Python modules are objects and have several useful attributes.  You can use this to easily test your modules as you write them, by including a special block of code that executes when you run the Python file on the command line.  Take the last few lines of humansize.py:
+
                                                                Running scripts
                                                                
+
                                                                Python modules are objects and have several useful attributes. You can use this to easily test your modules as you write them, by including a special block of code that executes when you run the Python file on the command line. Take the last few lines of humansize.py:
 
                                                                
 if __name__ == "__main__":
     print(approximate_size(1000000000000, False))
     print(approximate_size(1000000000000))
                                                                
 
                                                                
-
                                                                ☞Like C, Python uses == for comparison and = for assignment.  Unlike C, Python does not support in-line assignment, so there's no chance of accidentally assigning the value you thought you were comparing.
+
                                                                ☞Like C, Python uses == for comparison and = for assignment. Unlike C, Python does not support in-line assignment, so there's no chance of accidentally assigning the value you thought you were comparing.
 
                                                                
-
                                                                So what makes this if statement special?  Well, modules are objects, and all modules have a built-in attribute __name__.  A module's __name__ depends on how you're using the module.  If you import the module, then __name__ is the module's filename, without a directory path or file extension.
-
                                                                >>> import humansize
->>> humansize.__name__
+
                                                                So what makes this if statement special?  Well, modules are objects, and all modules have a built-in attribute __name__. A module's __name__ depends on how you're using the module. If you import the module, then __name__ is the module's filename, without a directory path or file extension.
+
                                                                >>> import humansize
+>>> humansize.__name__
 'humansize'
                                                                
-
                                                                But you can also run the module directly as a standalone program, in which case __name__ will be a special default value, __main__.  Python will evaluate this if statement, find a true expression, and execute the if code block.  In this case, to print two values.
-
                                                                c:\home\diveintopython3> c:\python30\python.exe humansize.py
+
                                                                But you can also run the module directly as a standalone program, in which case __name__ will be a special default value, __main__. Python will evaluate this if statement, find a true expression, and execute the if code block. In this case, to print two values.
+
                                                                c:\home\diveintopython3> c:\python30\python.exe humansize.py
 1.0 TB
 931.3 GiB
                                                                
-
                                                                Further reading
                                                                
+
                                                                Further reading
                                                                
 
-
                                                                © 2001-4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
-
-
-
-
+
                                                                © 2001–4, 2009 ℳark Pilgrim, CC-BY-SA-3.0
+
+
diff --git a/yuicompressor-2.4.2.jar b/yuicompressor-2.4.2.jar
new file mode 100644
index 0000000..c29470b
Binary files /dev/null and b/yuicompressor-2.4.2.jar differ