Learning Python - Mark Lutz [9]
Changes to Existing Material
In addition, some material from the prior edition has been reorganized, or supplemented with new examples. Multiple inheritance, for instance, gets a new case study example that lists class trees in Chapter 30; new examples for generators that manually implement map and zip are provided in Chapter 20; static and class methods are illustrated by new code in Chapter 31; package relative imports are captured in action in Chapter 23; and the __contains__, __bool__, and __index__ operator overloading methods are illustrated by example now as well in Chapter 29, along with the new overloading protocols for slicing and comparison.
This edition also incorporates some reorganization for clarity. For instance, to accommodate new material and topics, and to avoid chapter topic overload, five prior chapters have been split into two each here. The result is new standalone chapters on operator overloading, scopes and arguments, exception statement details, and comprehension and iteration topics. Some reordering has been done within the existing chapters as well, to improve topic flow.
This edition also tries to minimize forward references with some reordering, though Python 3.0’s changes make this impossible in some cases: to understand printing and the string format method, you now must know keyword arguments for functions; to understand dictionary key lists and key tests, you must now know iteration; to use exec to run code, you need to be able to use file objects; and so on. A linear reading still probably makes the most sense, but some topics may require nonlinear jumps and random lookups.
All told, there have been hundreds of changes in this edition. The next section’s tables alone document 27 additions and 57 changes in Python. In fact, it’s fair to say that this edition is somewhat more advanced, because Python is somewhat more advanced. As for Python 3.0 itself, though, you’re probably better off discovering most of this book’s changes for yourself, rather than reading about them further in this Preface.
Specific Language Extensions in 2.6 and 3.0
In general, Python 3.0 is a cleaner language, but it is also in some ways a more sophisticated language. In fact, some of its changes seem to assume you must already know Python in order to learn Python! The prior section outlined some of the more prominent circular knowledge dependencies in 3.0; as a random example, the rationale for wrapping dictionary views in a list call is incredibly subtle and requires substantial foreknowledge. Besides teaching Python fundamentals, this book serves to help bridge this knowledge gap.
Table 1 lists the most prominent new language features covered in this edition, along with the primary chapters in which they appear.
Table 1. Extensions in Python 2.6 and 3.0
Extension
Covered in chapter(s)
The print function in 3.0
11
The nonlocal x,y statement in 3.0
17
The str.format method in 2.6 and 3.0
7
String types in 3.0: str for Unicode text, bytes for binary data
7, 36
Text and binary file distinctions in 3.0
9, 36
Class decorators in 2.6 and 3.0: @private('age')
31, 38
New iterators in 3.0: range, map, zip
14, 20
Dictionary views in 3.0: D.keys, D.values, D.items
8, 14
Division operators in 3.0: remainders, / and //
5
Set literals in 3.0: {a, b, c}
5
Set comprehensions in 3.0: {x**2 for x in seq}
4, 5, 14, 20
Dictionary comprehensions in 3.0: {x: x**2 for x in seq}
4, 8, 14, 20
Binary digit-string support in 2.6 and 3.0: 0b0101, bin(I)
5
The fraction number type in 2.6 and 3.0: Fraction(1, 3)
5
Function annotations in 3.0: def f(a:99, b:str)->int
19
Keyword-only arguments in 3.0: def f(a, *b, c, **d)
18, 20
Extended sequence unpacking in 3.0: a, *b = seq
11, 13
Relative import syntax