Errata/Corrigendum

Text

Chapter 2

      This script prompts the user for a filename, opens the file, and loops over the (text) file and displays one line at a time, and finally closes the file. This technique or idiom is simple to understand and works great, especially with large files because you do not need the entire file in memory at the same time. As an alternative for shorter files, take a look at this similar piece of code:

filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
data = fobj.readlines()
fobj.close()
for eachLine in data:
      print eachLine,

52 :: 2.18 : How to Create Class Instances : In the (first [John Doe]) sample output for calling foo1.showname(), the output should not have "__main__." in it. In other words, it should just be:

>>> foo1.showname()
Your name is John Doe
My name is FooClass

Chapter 3

Even more importantly, our goal for keeping the text file platform-independent was defeated by the fopen() C library call on Win32 platforms. For each NEWLINE (\n or ASCII value 10) character encountered, it is replaced by the two Win32 line terminators RETURN (\r OR ASCII 13) and NEWLINE. This means that the original program created text files with \r\r\n between lines, a minor text file corruption and not our original intention.

The fix is to change the Python line terminator back to a solitary NEWLINE on line 30 and let the C library "do the right thing" for its respective platform. We apologize for any confusion caused for readers new to Python or cross-platform issues. Our original fix looked like this:

fobj.writelines(['%s\n' % x for x in all])

However, rather than process lines by adding a NEWLINE to each and sending the resulting list out to disk with the writelines() method, we preferred merging all of the text lines into a single string delimited by NEWLINE characters and performing a single write():

fobj.write('\n'.join(all))
(major patch [diff])

Now that we have the entire contents in memory, we need to dump it to the text file. Line 29 opens the file for write, and line 30 writes each line to the file. Every file requires a line terminator (or termination character[s]). The '\n'.join(all) takes each line of all (list of input strings), and join()s them together into one large string delimited by the NEWLINE character. That single string is then written out to disk with the file object's write() method.

Chapter 4

Chapter 5

>>> 5 % 2
1
>>> 8 % 4
0
>>> 6j-7 % 3
(-1+6j)

NEW -- Thanks to Greg Nofi (May 07) and Mark Ackerman (Jan 08)
133 :: 5.5.3 : Exponentiation : In the final code snippet, we showed an error when raising a number to a negative power. As of Python 2.2, the operands are correctly cast to floats as well as the result (this applies to both the ** operator as well as pow()):

>>> 4 ** -1
0.25

Chapter 6

173 :: 6.3.2 : Example 6.1 : Line 1 is missing the (root directory) first forward slash in the *ix start-up directive; it should be, #!/usr/bin/env python, and line 5 should refer to string.ascii_letters.

#!/usr/bin/env python

from keyword import kwlist
import string

ALPHAS = string.ascii_letters + '_'
NUMS = string.digits

def main():
    print 'Welcome to the Identifier Checker v2.0'
    myInput = raw_input('Identifier to test? ').strip()

    if len(myInput) == 0:
        print "ERROR: no identifier candidate entered"
        return

    if myInput in kwlist:
        print "ERROR: %r is a keyword" % myInput
        return

    alnums = ALPHAS + NUMS
    for i, c in enumerate(myInput):
        if i == 0 and c not in ALPHAS:
            print 'ERROR: first symbol must be alphabetic'
            break
        if c not in alnums:
            print 'ERROR: remaining symbols must be alphanumeric'
            break
    else:
        print "okay as an identifier"

if __name__ == '__main__':
    main()

188-190 :: 6.22 : Table 6.6 : The string.{center,[rl]just}() methods now take a fillchar=' ' argument where fillchar is the character to use for padding. It should have a (new) footnote "g": "New or changed in in Python 2.4."

189-190 :: 6.22 : Table 6.6 : The string.*strip() methods now take a chars=[ \t\n\v\f\r] argument where chars can be any sequence of leading and/or trailing characters to remove. It should have a (new) footnote "f": "New or changed in in Python 2.2.2."

190 :: 6.22 : Table 6.6 : The string.rsplit(str=' ', num=string.count(str) method is missing: "Same as split(), but search backward in string." It should have a (new) footnote "g": "New or changed in in Python 2.4."

190 :: 6.22 : Table 6.6 : The signature for string.splitlines() is incorrect. It should be: string.splitlines(keepends=False): "Splits string at all NEWLINEs and returns a list of each line with NEWLINEs removed unless keepends=True.

199 :: 6.8.3 : The last few sentences of the first complete paragraph on this page are erroneous now. The string module was updated with Unicode equivalent constants as well as the new string templates as described earlier in section 6.4.2 on p. 182. The paragraph should end with the final sentence, "Both behave very similarly."

240 :: 6.19 : Fix this typo in the final paragraph of this section at the top of the page: "... also contains the same for sequence types." (This refers to the functional equivalents to sequence type operators.) Also, the final three sentences (with the first beginning with, "Finally,...") SHOULD BE REMOVED as Python now does support subclassing of the standard types.

247-248 :: 6.22 :: Exercise 6-7 and "Example 6.4" : buggy.py is really Example 6.5. (Example 6.4 is queue.py back on p. 229.) This is just a minor detail. The real problem is that in lines 11 and 27 of buggy.py, the references to fac_list erroneously use single quotes. In other words, it should be using backticks or repr(), i.e., `fac_list` or repr(fac_list). This was NOT a typo in the First Edition however.

250 :: 6.22 :: Exercise 6-18 : The subtitle of this problem should read, "zip() Built-in Function." and refers to the reading in Section 6.13.2.

Chapter 7

267 :: 7.4 : In the first sentence of the second paragraph (right below the code snippet), "directory" is the wrong word and should be changed: "... add the contents of one dictionary to another."

NEW (May 08)
286 :: 7.12 :: Exercise 7-5 : In exercise 5(c), the parenthesized list should remove reference to the now-obsolete rotor module and add in a few new ones. It should be replaced with: "(see the getpass, md5, crypt [Unix-only], hashlib [2.5], and other cryptographic modules)."

Chapter 8

303 :: 8.6.5 : There is a misspelling of "returning" in the final sentence of this paragraph. Also, so readers don't have to hunt for the reference, the final sentence should end with, "... similar to views as discussed in the previous chapter at the end of Section 7.4."

Chapter 9

Chapter 10

ccfile = None
try:
    try:
	ccfile = open('carddata.txt', 'r')
	txns = ccfile.readlines()
    except IOError:
        log.write('no txns this month\n')
finally:
    if ccfile:
        ccfile.close()

and

ccfile = None
try:
    try:
	ccfile = open('carddata.txt', 'r')
	txns = ccfile.readlines()
    finally:
	if ccfile:
	    ccfile.close()
except IOError:
    log.write('no txns this month\n')

386, 394 :: 10.5, 10.8 : In the final paragraph for section 10.5, we describe the obsolescence of string exceptions. The raising exceptions in Python 2.5 resulting in a warning can be further clarified that it will no longer be allowed in 2.6. Similarly, the catching of string exceptions results in a warning beginning in 2.6 but will not be allowed in 2.7.
This clarification can also be carried to the second-to-last paragraph of section 10.8. It is erroneously stated that raising of string exceptions is not allowed in 2.5, which it is allowed but generates a warning. Similarly for the catching of string exceptions, it's really only disallowed starting in 2.7; in 2.6, a warning is generated.

390 :: 10.7.1 : With regards to the __debug__ system variable, after Python 2.2, rather than having values of 1 and 0, it is a Boolean, thus have values of True and False, respectively.

391-393 :: 10.8 : Table 10.2 : Various editing errors exist in the table of standard exceptions:
      • (391) The 2nd entry for SystemExit should have a footnote of "b" just like it is in the entry above. The entire row should also be grayed out, indicating the change that occurred back when Python 2.5 was released.
      • (392) (The 2nd entry for) KeyboardInterrupt should have a footnote of "c" just like it is in the entry on the previous page. The entire row should also be grayed out, indicating the change that occurred back when Python 2.5 was released.
      • (392) TabError should be indented... it is derived from IndentationError.
      • (393) UnicodeTranslateError should have a footnote of "i" (not "f").
      • (393) PendingDeprecationWarning should be one word.
      • (393) Footnotes "b" and "c": the word "subclassed" should be "derived from".
      • (393) Footnote "f" is a duplicate of "h" and SHOULD BE REMOVED. All remaining footnotes and corresponding tagged text should be adjusted accordingly.

395-397 :: 10.9 :: Example 10.2 : myexc.py
Line 77 is missing the full function call using the module name: tempfile.mktemp(). Also, since file() is now a factory function, we've renamed all such named references to fn. Finally, enter your own hostnames on line 101 rather than using our test lab computers which certainly won't work for you. (critical patch)

Chapter 11

NEW -- Thanks to Tony Tang (May 08)
434 :: 11.6.1 : In the code snippet featuring tupeVarArgs(), the 2nd print statement should refer to arg2 and not arg1, as in:
print 'formal arg2:', arg2.

443 :: 11.7.2 :: Figure 11-1 : The "0" and "1"s inside the box representing the boolean function bool_func() should instead be represented by the Boolean values False and True, respectively. Those values will be integers only prior to Python 2.3.

444 :: 11.7.2 :: filter() : The 2nd paragraph (right beneath the code snippet) mistakenly refers to having two functions, one of which is main(). (We removed this function, pushed the body out to the global part of the code, and did not update the text. Rewrite this paragraph as:

This code snippet contains a function odd() which returns True if the numeric argument that was passed to it was odd and False otherwise. The main portion of the snippet creates a list of nine random numbers in the range 1-99. [Note that random.randint() is inclusive and that we could have used the equivalent random.randrange(1, 100), which we recommend because it has the same calling convention as the built-in function range().] Then filter() does its work: call odd() on each element of the list allNums and return a new list containing just those items of allNums for which odd() returned True, and that new list is then displayed to the user with print.

465 :: 11.8.5 : Just before the middle of the page, in the final definition of foo(), the calls to bar() should not have any arguments. We stated immediately above how the previous code snippet required altering those calls to take a parameter which was not desired.

469 :: 11.10.1 : In the code snippet in the middle of the page, we should have used random.randrange(), not random.randint() as the latter will give an error if the random index chosen is the length of the list. randrange() has a similar syntax to range() meaning that it goes up to but does not include the (second or only) index. Also, the checking of the sequence length is unnecessary as it will return False if it is empty. Given these changes, we can shorten the code to the following:

from random import randrange as rr

def randGen(aList):
    while aList:
	yield aList.pop(rr(len(aList)))

Finally, all three of the code snippets used in this subsection can now be downloaded here (as of Dec 6).

Chapter 13

543 :: 13.8.1 : In the TestStaticMethod example, the call foo = staticmethod(foo) should be dedented to the same level as the definition of the foo() function, e.g.,

class TestStaticMethod:
    def foo():
	print 'calling static method foo()'
    foo = staticmethod(foo)

553 :: 13.11.3 : In the SortedKeyDict example output, the supposedly sorted list when using keys() is out-of-order due to an error correction: "xin-yi" was misspelled as "hsin-yi", and the edit was made without reordering the list correctly. it should be:

By keys(): ['hui-jun', 'xin-yi', 'zheng-cai']

604 :: 13.16.4 :: Example 13.9 : descr.py
For this code to work with Python 2.5 and newer, delete line 31. For this code to work with any version of Python, indent line 34 one level (four spaces to the right). For the __set__() method, the open() statement on line 29 should really be moved to the innermost try block immediately below it (between lines 31-32), and the succeeding except should also be monitoring for IOError — just like in the above __get__() method. Less importantly, name should not not have a default value as it does now on line 9. Below, we post two patches, one for users of Python 2.5 and newer as well as one for those using Python 2.4.3 and older.
(critical patch [diff]; pre-2.5 patch [diff])

607 :: 13.16.4 : Properties and property() Built-in Function : The last part of the final sentence in the first complete paragraph at the top of the page before the definition of the ProtectAndHideX class should be changed to the following: "... encrypting it by using the bitwise complement operator:". (The XOR operator is binary and not used in this example.)

609 :: 13.16.4 : Properties and property() Built-in Function : I must have done this really late at night as the code for the HideX class will not work with using the property() factory function as a decorator (in any version of Python). You will always have to use the x = property(**x()) syntax. Likewise, the text of Exercise 13-21 on p. 625 has to be changed (see below). The reason why it does not work is because the defition of x() will not automatically return the inner function objects so that the property can be created. That's why you still need to execute x() in order to get it to call locals() so that the fget() and fset() names and objects are returned. How these objects help create the property is still the main point of Exercise 13-21. In the code, remove the @property decorator and add x = property(**x()) right beneath the function declaration. Let's also change the class name to something more appropriate for this example:

#!/usr/bin/env python
'ProtectAndHideX.py -- protect the "x" attribute'

class ProtectAndHideX(object):
    def __init__(self, x):
        self.x = x

        def x():
            def fget(self):
		return ~self.__x

            def fset(self, x):
                assert isinstance(x, int), \
                    '"x" must be an integer!'
                self.__x = ~x

            return locals()

        x = property(**x())

inst = ProtectAndHideX(10)
print 'inst.x has a value of:', inst.x
inst.x = 20
print 'inst.x has a value of:', inst.x
inst.x.fset(40)   # sorry!
print 'inst.x has a value of:', inst.x

You can download this code here. The output of executing the code above will look like this:

inst.x has a value of: 10
inst.x has a value of: 20
Traceback (most recent call last):
  File "", line 1, in ?
  File "ProtectAndHideX.py", line 22, in ?
    inst.x.fset(40)   # sorry!
AttributeError: 'int' object has no attribute 'fset'

In the final paragraph on this page, keep only the first sentence, beginning with, "Our code works exactly as before...." Drop the final 2 sentences.

def __repr__(self):
    return repr(self.value)

Toward the end of section 13.16.4, we used the syntax x = property(**x()) to create a property for the x attribute for the HideX class. How does this idiom, including the enclosed call to x(), actually create the property?

Chapter 14

664 :: 14.7.1 :: Example "14.4" : Globally replace "14.4" with "14.3" ... there is no Example 14.4.

UPDATED (May 08)
668-669 :: 14.10 :: Exercise 14-1 : There should be 13 exercises in this chapter:

• The first two problems are accidentally merged into Exercise 14-1. The third is missing.
• A new Exercise 14-2 begins labeled: "exec versus eval()". Only exec should be bolded, not the remainder of the problem.
• A missing Exercise 14-3 follows: "Statements vs. Expressions. What are the differences between statements and expressions?"
• Renumber the remaining problems accordingly, i.e., the printed Exercise "14-2" should be Exercise "14-4" instead.

Chapter 16

Chapter 17

1. Make the FTP client box bigger and make the FTP server box smaller so they are nearly the same size... there is no size differentiation between client and server, so the diagram should reflect that.
2. Move "M (> 1023)" left just above the top solid line connecting the FTP client box and the Internet cloud, symmetric to where "M + 1" is below the bottom solid line.
3. Move "ctrl/cmd" down so it's just above the top dashed line inside the Internet cloud
4. Move "data" to be centered just below the bottom dashed line inside the Internet cloud
5. Change "20 or" to "20 [active] or"
6. Change "N (> 1023)" to "N (> 1023) [passive]"
7. Delete "(Active)(Passive)"

754 :: 17.2.6 : Example 17.1 : Line-by-Line Explanation : Lines 11-44 :

1. (middle paragraph) Add one more sentence: "After the transfer has completed, we would then call loc.close()."
2. (final paragraph) Strike "if it is there": "...we remove the empty file if it is there to avoid clutter...".
3. (final paragraph) Add a new second-to-last sentence: "We should probably put some error-checking around that call to os.unlink(FILE) in case the file does not exist."
4. (final paragraph) Change the final sentence to: "Finally, to avoid another pair of lines (lines 43-44) that close the FTP connection and return, we use an else clause (lines 35-42)."

758 :: 17.3.4 : Table 17.2 : In the entry for "xhdr", move the "[" back two characters, to, xhdr(hdr, artrg[, ofile])

Line 60 is a generator expression. It works like a list comprehension only it does lazy evalution and does not build the entire results list when this line is executed. (The entire dataset, data, is already taking enough memory as it is!) Rather, each line is only processed when its turn comes up in the loop below on line 62. Generator expressions were added in Python 2.4, so if you are using an earlier release, the easiest fix while minimizing memory use is to add a new statement in between lines 62 and 63: line = line.rstrip(). If memory is not a concern, then just use a list comprehension instead (change the parentheses to square brackets).

772 :: 17.4.8 : Figure 17-3 : The not-well-arranged text on the second MUA down on the left should read, "IMAP4/POP3 (receive)", similar to the one for the bottom MUA as well as the one on the far right.

Chapter 18

Chapter 19

Chapter 20

868-869 :: 20.2.4 :: Line-by-Line Explanation :: Lines 24-29 : Change the filename to urlopenAuth.py (see next erratum). The current name (urlopen-auth.py) will not allow the module to be imported since '-' is not a valid Python identifier.

871 :: 20.3 :: Example 20.2 : The code for the __init__() and filename() methods (lines 15-34) are not indented properly... there should be 4 spaces of indentation for these methods.

Chapter 21

Chapter 23

Appendix B

NEW -- Thanks to Raven Erebus (May 08)
1038 :: File Object Methods and Data Attributes : The section title has "Attributes" misspelled... remove the extra "o".

CREDITS