Errata

In Table 15-9, the SimpleQueue is described as "an unbounded FIFO queue lacking the methods full, task_done, and join (see Table 15-10)" which suggests that these methods are listed in 15-10, but only the method full is listed there. The task_done and join methods are only explained in the text surrounding the table.

Note from the Author or Editor:
Thanks for submitting. In many of the tables in the book, we could not list every related item for each class or module, else the book would easily exceed 900 pages. And so we would choose selected items to include, and direct the reader to online resources for more complete docs; that is the case for this table as well.

To help minimize the confusion described in this erratum, we propose changing the description in Table 15-9 to "an unbounded FIFO queue lacking the methods full, task_done, and join (see Table 15-10 and the following text)".

in methods list, missing method `__rtruediv__` after `__radd__`

Note from the Author or Editor:
The list of method names should read in this order:
__radd__, __rfloordiv__, __rmod__, __rmul__, __rsub__, __rtruediv__, __rmatmul__

In the description, the first sentence should start "The operators y+x, y//x, y%x, y*x, y-x, y/x, y@x respectively call these methods on x..."

Book states: "If a key's value appears more than once in a dictionary expression, only an arbitrary one of the items with that key is kept in the resulting dictionary object -- dictionaries do not support duplicate keys."

Official python docs (at both the current 3.12.4 version and 3.7) state: "If a key occurs more than once, the last value for that key becomes the corresponding value in the new dictionary." Later on, it is mentioned that keyword arguments are incorporated in the same way - after the iterable/mapping argument.

Note from the Author or Editor:
Replace cited sentence with:

Dictionaries maintain their keys in the order that they are inserted. If a key appears more than once in a dictionary expression, the first occurrence of that key determines the key's position in the dictionary’s iteration order. But only the last value for that key is kept in the resulting dictionary object - dictionaries do not support duplicate keys. (For a dictionary-type class that stores multiple values for a given key, see the defaultdict(list) example on page 267.)

Book: "Generators are also callable"

Due to the terminology confusion explained on page 109, it would be more accurate to say "Generator functions are also callable"

Note from the Author or Editor:
Change "Generators are also callable" to "Generator functions are also callable"

Regular expression should be `r'Name: (\S+)` to capture a full name (currently just captures the first character). Occurs in 2 places in this code example.

The bound method read-only attributes im_class, im_func, and im_self were removed in the transition to Python 3. im_class was replaced by __self__, im_func was replaced by __func__, and im_class does not have a direct replacement, but class information can be inferred from __func__.__qualname__ or from the instance's __class__.

Note from the Author or Editor:
Replace paragraph with:

A bound method has two readonly attributes in addition to those of the function object it wraps: __func__ is the wrapped function, and __self__ refers to x, the object from which you got the method.

You don't need to print(AClass.astatic()), as that method already prints the desired output. The extra print() calls in this line and the next result in a couple of 'None' lines being printed to the output.

Note from the Author or Editor:
Remove print() function calls in last 2 lines of the code example, so that the last 3 lines read:

an_instance = AClass()
AClass.astatic() # prints: a static method
an_instance.astatic() # prints: a static method

The code examples for map() read as:
-------
For example, map(func, seq) is just like the generator expression:

(func(item) for item in seq).map(func, seq1, seq2)

is just like the generator expression:

(func(a, b) for a, b in zip(seq1, seq2))
-------


The first snippet is in error, and should be merged with the intervening text, as follows:
-------
For example, map(func, seq) is just like the generator expression:

(func(item) for item in seq)

map(func, seq1, seq2) is just like the generator expression:

(func(a, b) for a, b in zip(seq1, seq2))
-------

Classes Ps1 and Ps2 are defined as inheriting from object, this is no longer necessary in Python 3 and should be removed.

Just declare them as

class Ps1:
... with remaining code ...

class Ps2:
... with remaining code ...

Class KeyHeap is defined as inheriting from object. This is a legacy from Python 2, no longer required in Python 3. The first line of the class declaration should be:

class KeyHeap:

Omitted entries for str.partition and str.rpartition.

Consider merging all the is* methods and r* methods into consolidated entries to save table space.

The second line of the example reads:

>>> print('{name} is {n} characters long'

In the following example output, Dawn is enclosed in single quotes. To get this, the example print statement should be:

>>> print('{name!r} is {n} characters long'

The entry lists "Positional-only and named-only parameters (/ and * arg separators)". Only positional-only arguments (/ symbol in function signature) are new in Python 3.8 - see PEP-570. Keyword-only arguments (* symbol) were introduced back in Python 3.0 - see PEP-3102.

Note from the Author or Editor:
Thank you for submitting! The wording in the table should be changed to read "Positional-only '/' argument separators", since '*' argument separators were already supported as of Python 3.0. We'll also revisit the text on pp.95-97 to make sure that version markers are correctly placed.

enum.StrEnum was erroneously listed in the table of changes in Python 3.10, but this change was not actually made until Python 3.11. This entry should be moved to the table for Python 3.11 (approx. p. 684)

Affects all versions and translations of this book.