LearningPython.pdf
0 likes56 views
This document provides an overview of the fifth edition of the book "Learning Python" by Mark Lutz. It discusses the book's contents, contributors, copyright information, and revision history. The book is published by O'Reilly Media and is intended to teach readers how to program in the Python language. It covers topics such as Python basics, built-in types, statements and syntax, and other core programming concepts.
![Learning Python, Fifth Edition
by Mark Lutz
Copyright © 2013 Mark Lutz. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions
are also available for most titles (http://my.safaribooksonline.com). For more information, contact our
corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com.
Editor: Rachel Roumeliotis
Production Editor: Christopher Hearse
Copyeditor: Rachel Monaghan
Proofreader: Julie Van Keuren
Indexer: Lucie Haskins
Cover Designer: Randy Comer
Interior Designer: David Futato
Illustrator: Rebecca Demarest
June 2013: Fifth Edition.
Revision History for the Fifth Edition:
2013-06-07 First release
See http://oreilly.com/catalog/errata.csp?isbn=9781449355739 for release details.
Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of
O’Reilly Media, Inc. Learning Python, 5th Edition, the image of a wood rat, and related trade dress are
trademarks of O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a
trademark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and authors assume
no responsibility for errors or omissions, or for damages resulting from the use of the information con-
tained herein.
ISBN: 978-1-449-35573-9
[QG]
1370970520](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-4-320.jpg)
![c:code> c:python33python
Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ...
Type "help", "copyright", "credits" or "license" for more information.
>>> ^Z
Alternatively, you can run a “cd” change-directory command to go to Python’s install
directory before typing python—try the cd c:python33 command on Windows, for
example:
c:code> cd c:python33
c:Python33> python
Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ...
Type "help", "copyright", "credits" or "license" for more information.
>>> ^Z
But you’ll probably want to set your PATH eventually, so a simple “python” suffices. If
you don’t know what PATH is or how to set it, see Appendix A—it covers environment
variables like this whose usage varies per platform, as well as Python command-line
arguments we won’t be using much in this book. The short story for Windows users:
see the Advanced settings in the System entry of your Control Panel. If you’re using
Python 3.3 and later, this is now automatic on Windows, as the next section explains.
New Windows Options in 3.3: PATH, Launcher
The foregoing section and much of this chapter at large describe the generic state of
play for all 2.X and 3.X Pythons prior to version 3.3. Starting with Python 3.3, the
Windows installer has an option to automatically add Python 3.3’s directory to your
system PATH, if enabled in the installer’s windows. If you use this option, you won’t
need to type a directory path or issue a “cd” to run python commands as in the prior
section. Be sure to select this option during the install if you want it, as it’s currently
disabled by default.
More dramatically, Python 3.3 for Windows ships with and automatically installs the
new Windows launcher—a system that comes with new executable programs, py with
a console and pyw without, that are placed in directories on your system path, and so
may be run out of the box without any PATH configurations, change-directory com-
mands, or directory path prefixes:
c:code> py
Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ...
Type "help", "copyright", "credits" or "license" for more information.
>>> ^Z
c:code> py −2
Python 2.7.3 (default, Apr 10 2012, 23:24:47) [MSC v.1500 64 bit (AMD64)] ...
Type "help", "copyright", "credits" or "license" for more information.
>>> ^Z
c:code> py −3.1
Python 3.1.4 (default, Jun 12 2011, 14:16:16) [MSC v.1500 64 bit (AMD64)] ...
46 | Chapter 3: How You Run Programs](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-98-320.jpg)
![concept will be more useful when you start defining objects such as functions and
classes in your modules: such objects become reusable software components that can
be accessed by name from one or more client modules.
In practice, module files usually define more than one name to be used in and outside
the files. Here’s an example that defines three:
a = 'dead' # Define three attributes
b = 'parrot' # Exported to other files
c = 'sketch'
print(a, b, c) # Also used in this file (in 2.X: print a, b, c)
This file, threenames.py, assigns three variables, and so generates three attributes for
the outside world. It also uses its own three variables in a 3.X print statement, as we
see when we run this as a top-level file (in Python 2.X print differs slightly, so omit its
outer parenthesis to match the output here exactly; watch for a more complete ex-
planation of this in Chapter 11):
% python threenames.py
dead parrot sketch
All of this file’s code runs as usual the first time it is imported elsewhere, by either an
import or from. Clients of this file that use import get a module with attributes, while
clients that use from get copies of the file’s names:
% python
>>> import threenames # Grab the whole module: it runs here
dead parrot sketch
>>>
>>> threenames.b, threenames.c # Access its attributes
('parrot', 'sketch')
>>>
>>> from threenames import a, b, c # Copy multiple names out
>>> b, c
('parrot', 'sketch')
The results here are printed in parentheses because they are really tuples—a kind of
object created by the comma in the inputs (and covered in the next part of this book)
—that you can safely ignore for now.
Once you start coding modules with multiple names like this, the built-in dir function
starts to come in handy—you can use it to fetch a list of all the names available inside
a module. The following returns a Python list of strings in square brackets (we’ll start
studying lists in the next chapter):
>>> dir(threenames)
['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'b', 'c']
The contents of this list have been edited here because they vary per Python version.
The point to notice here is that when the dir function is called with the name of an
importedmodule in parentheseslikethis,itreturnsallthe attributesinsidethatmodule.
Some of the names it returns are names you get “for free”: names with leading and
trailing double underscores (__X__) are built-in names that are always predefined by
70 | Chapter 3: How You Run Programs](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-122-320.jpg)
![rectory when you import). What happens? (Hint: is there still a module1.pyc byte
code file in the original directory, or something similar in a __pycache__ subdir-
ectory there?)
4. Scripts. If your platform supports it, add the #! line to the top of your mod-
ule1.py module file, give the file executable privileges, and run it directly as an
executable. What does the first line need to contain? #! usually only has meaning
on Unix, Linux, and Unix-like platforms such as Mac OS X; if you’re working on
Windows, instead try running your file by listing just its name in a Command
Promptwindowwithouttheword“python”beforeit(thisworksonrecentversions
of Windows), via the Start→Run... dialog box, or similar. If you are using Python
3.3 or the Windows launcher that installs with it, experiment with changing your
script’s #! line to launch different Python versions you may have installed on your
computer (or equivalently, work through the tutorial in Appendix B).
5. Errors and debugging. Experiment with typing mathematical expressions and as-
signments at the Python interactive command line. Along the way, type the ex-
pressions 2 ** 500 and 1 / 0, and reference an undefined variable name as we did
early on in this chapter. What happens?
You may not know it yet, but when you make a mistake, you’re doing exception
processing: a topic we’ll explore in depth in Part VII. As you’ll learn there, you are
technically triggering what’s known as the default exception handler—logic that
prints a standard error message. If you do not catch an error, the default handler
does and prints the standard error message in response.
Exceptions are also bound up with the notion of debugging in Python. When you’re
first starting out, Python’s default error messages on exceptions will probably pro-
vide as much error-handling support as you need—they give the cause of the error,
as well as showing the lines in your code that were active when the error occurred.
For more about debugging, see the sidebar “Debugging Python Code”
on page 83.
6. Breaks and cycles. At the Python command line, type:
L = [1, 2] # Make a 2-item list
L.append(L) # Append L as a single item to itself
L # Print L: a cyclic/circular object
What happens? In all recent versions of Python, you’ll see a strange output that
we’ll describe in the solutions appendix, and which will make more sense when
we study references in the next part of the book. If you’re using a Python version
older than 1.5.1, a Ctrl-C key combination will probably help on most platforms.
Why do you think your version of Python responds the way it does for this code?
If you do have a Python older than Release 1.5.1 (a hopefully rare
scenario today!), make sure your machine can stop a program with
a Ctrl-C key combination of some sort before running this test, or
you may be waiting a long time.
88 | Chapter 3: How You Run Programs](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-140-320.jpg)
![Table 4-1. Built-in objects preview
Object type Example literals/creation
Numbers 1234, 3.1415, 3+4j, 0b111, Decimal(), Fraction()
Strings 'spam', "Bob's", b'ax01c', u'spxc4m'
Lists [1, [2, 'three'], 4.5], list(range(10))
Dictionaries {'food': 'spam', 'taste': 'yum'}, dict(hours=10)
Tuples (1, 'spam', 4, 'U'), tuple('spam'), namedtuple
Files open('eggs.txt'), open(r'C:ham.bin', 'wb')
Sets set('abc'), {'a', 'b', 'c'}
Other core types Booleans, types, None
Program unit types Functions, modules, classes (Part IV, Part V, Part VI)
Implementation-related types Compiled code, stack tracebacks (Part IV, Part VII)
AlsoshowninTable4-1,programunitssuchasfunctions,modules,andclasses—which
we’ll meet in later parts of this book—are objects in Python too; they are created with
statements and expressions such as def, class, import, and lambda and may be passed
around scripts freely, stored within other objects, and so on. Python also provides a
set of implementation-related types such as compiled code objects, which are generally
of interest to tool builders more than application developers; we’ll explore these in later
parts too, though in less depth due to their specialized roles.
Despiteitstitle,Table4-1isn’treallycomplete,becauseeverythingweprocessinPython
programs is a kind of object. For instance, when we perform text pattern matching in
Python, we create pattern objects, and when we perform network scripting, we use
socket objects. These other kinds of objects are generally created by importing and
using functions in library modules—for example, in the re and socket modules for
patterns and sockets—and have behavior all their own.
We usually call the other object types in Table 4-1 core data types, though, because
they are effectively built into the Python language—that is, there is specific expression
syntax for generating most of them. For instance, when you run the following code
with characters surrounded by quotes:
>>> 'spam'
you are, technically speaking, running a literal expression that generates and returns a
new string object. There is specific Python language syntax to make this object. Simi-
larly, an expression wrapped in square brackets makes a list, one in curly braces makes
a dictionary, and so on. Even though, as we’ll see, there are no type declarations in
Python, the syntax of the expressions you run determines the types of objects you create
and use. In fact, object-generation expressions like those in Table 4-1 are generally
where types originate in the Python language.
96 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-148-320.jpg)
![This nested-call form works from inside out—first converting the ** result’s number
to a string of digits with the built-in str function, and then getting the length of the
resulting string with len. The end result is the number of digits. str and len work on
many object types; more on both as we move along.
On Pythons prior to 2.7 and 3.1, once you start experimenting with floating-point
numbers, you’re likely to stumble across something that may look a bit odd at first
glance:
>>> 3.1415 * 2 # repr: as code (Pythons < 2.7 and 3.1)
6.2830000000000004
>>> print(3.1415 * 2) # str: user-friendly
6.283
The first result isn’t a bug; it’s a display issue. It turns out that there are two ways to
print every object in Python—with full precision (as in the first result shown here), and
inauser-friendlyform(asin thesecond).Formally,thefirstformisknownasanobject’s
as-code repr, and the second is its user-friendly str. In older Pythons, the floating-point
repr sometimes displays more precision than you might expect. The difference can also
matter when we step up to using classes. For now, if something looks odd, try showing
it with a print built-in function call statement.
Better yet, upgrade to Python 2.7 and the latest 3.X, where floating-point numbers
display themselves more intelligently, usually with fewer extraneous digits—since this
book is based on Pythons 2.7 and 3.3, this is the display form I’ll be showing throughout
this book for floating-point numbers:
>>> 3.1415 * 2 # repr: as code (Pythons >= 2.7 and 3.1)
6.283
Besides expressions, there are a handful of useful numeric modules that ship with
Python—modules are just packages of additional tools that we import to use:
>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887
The math module contains more advanced numeric tools as functions, while the ran
dom module performs random-number generation and random selections (here, from a
Python list coded in square brackets—an ordered collection of other objects to be in-
troduced later in this chapter):
>>> import random
>>> random.random()
0.7082048489415967
>>> random.choice([1, 2, 3, 4])
1
Python also includes more exotic numeric objects—such as complex, fixed-precision,
and rational numbers, as well as sets and Booleans—and the third-party open source
98 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-150-320.jpg)
![extension domain has even more (e.g., matrixes and vectors, and extended precision
numbers). We’ll defer discussion of these types until later in this chapter and book.
So far, we’ve been using Python much like a simple calculator; to do better justice to
its built-in types, let’s move on to explore strings.
Strings
Strings are used to record both textual information (your name, for instance) as well
as arbitrary collections of bytes (such as an image file’s contents). They are our first
example of what in Python we call a sequence—a positionally ordered collection of
other objects. Sequences maintain a left-to-right order among the items they contain:
their items are stored and fetched by their relative positions. Strictly speaking, strings
are sequences of one-character strings; other, more general sequence types include
lists and tuples, covered later.
Sequence Operations
As sequences, strings support operations that assume a positional ordering among
items. For example, if we have a four-character string coded inside quotes (usually of
the single variety), we can verify its length with the built-in len function and fetch its
components with indexing expressions:
>>> S = 'Spam' # Make a 4-character string, and assign it to a name
>>> len(S) # Length
4
>>> S[0] # The first item in S, indexing by zero-based position
'S'
>>> S[1] # The second item from the left
'p'
In Python, indexes are coded as offsets from the front, and so start from 0: the first item
is at index 0, the second is at index 1, and so on.
Notice how we assign the string to a variable named S here. We’ll go into detail on how
this works later (especially in Chapter 6), but Python variables never need to be declared
ahead of time. A variable is created when you assign it a value, may be assigned any
type of object, and is replaced with its value when it shows up in an expression. It must
also have been previously assigned by the time you use its value. For the purposes of
this chapter, it’s enough to know that we need to assign an object to a variable in order
to save it for later use.
In Python, we can also index backward, from the end—positive indexes count from
the left, and negative indexes count back from the right:
>>> S[-1] # The last item from the end in S
'm'
>>> S[-2] # The second-to-last item from the end
'a'
Strings | 99](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-151-320.jpg)
![Formally, a negative index is simply added to the string’s length, so the following two
operations are equivalent (though the first is easier to code and less easy to get wrong):
>>> S[-1] # The last item in S
'm'
>>> S[len(S)-1] # Negative indexing, the hard way
'm'
Notice that we can use an arbitrary expression in the square brackets, not just a hard-
coded number literal—anywhere that Python expects a value, we can use a literal, a
variable, or any expression we wish. Python’s syntax is completely general this way.
In addition to simple positional indexing, sequences also support a more general form
of indexing known as slicing, which is a way to extract an entire section (slice) in a single
step. For example:
>>> S # A 4-character string
'Spam'
>>> S[1:3] # Slice of S from offsets 1 through 2 (not 3)
'pa'
Probably the easiest way to think of slices is that they are a way to extract an entire
column from a string in a single step. Their general form, X[I:J], means “give me ev-
erything in X from offset I up to but not including offset J.” The result is returned in a
new object. The second of the preceding operations, for instance, gives us all the char-
acters in string S from offsets 1 through 2 (that is, 1 through 3 – 1) as a new string. The
effect is to slice or “parse out” the two characters in the middle.
In a slice, the left bound defaults to zero, and the right bound defaults to the length of
the sequence being sliced. This leads to some common usage variations:
>>> S[1:] # Everything past the first (1:len(S))
'pam'
>>> S # S itself hasn't changed
'Spam'
>>> S[0:3] # Everything but the last
'Spa'
>>> S[:3] # Same as S[0:3]
'Spa'
>>> S[:-1] # Everything but the last again, but simpler (0:-1)
'Spa'
>>> S[:] # All of S as a top-level copy (0:len(S))
'Spam'
Note in the second-to-last command how negative offsets can be used to give bounds
for slices, too, and how the last operation effectively copies the entire string. As you’ll
learn later, there is no reason to copy a string, but this form can be useful for sequences
like lists.
Finally, as sequences, strings also support concatenation with the plus sign (joining two
strings into a new string) and repetition (making a new string by repeating another):
>>> S
'Spam'
100 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-152-320.jpg)
![>>> S + 'xyz' # Concatenation
'Spamxyz'
>>> S # S is unchanged
'Spam'
>>> S * 8 # Repetition
'SpamSpamSpamSpamSpamSpamSpamSpam'
Notice that the plus sign (+) means different things for different objects: addition for
numbers, and concatenation for strings. This is a general property of Python that we’ll
call polymorphism later in the book—in sum, the meaning of an operation depends on
the objects being operated on. As you’ll see when we study dynamic typing, this poly-
morphismpropertyaccountsformuchoftheconcisenessandflexibilityofPythoncode.
Because types aren’t constrained, a Python-coded operation can normally work on
many different types of objects automatically, as long as they support a compatible
interface (like the + operation here). This turns out to be a huge idea in Python; you’ll
learn more about it later on our tour.
Immutability
Also notice in the prior examples that we were not changing the original string with
any of the operations we ran on it. Every string operation is defined to produce a new
string as its result, because strings are immutable in Python—they cannot be changed
in place after they are created. In other words, you can never overwrite the values of
immutable objects. For example, you can’t change a string by assigning to one of its
positions, but you can always build a new one and assign it to the same name. Because
Python cleans up old objects as you go (as you’ll see later), this isn’t as inefficient as it
may sound:
>>> S
'Spam'
>>> S[0] = 'z' # Immutable objects cannot be changed
...error text omitted...
TypeError: 'str' object does not support item assignment
>>> S = 'z' + S[1:] # But we can run expressions to make new objects
>>> S
'zpam'
Every object in Python is classified as either immutable (unchangeable) or not. In terms
of the core types, numbers, strings, and tuples are immutable; lists, dictionaries, and
sets are not—they can be changed in place freely, as can most new objects you’ll code
with classes. This distinction turns out to be crucial in Python work, in ways that we
can’t yet fully explore. Among other things, immutability can be used to guarantee that
an object remains constant throughout your program; mutable objects’ values can be
changed at any time and place (and whether you expect it or not).
Strings | 101](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-153-320.jpg)
![Strictly speaking, you can change text-based data in place if you either expand it into a
list of individual characters and join it back together with nothing between, or use the
newer bytearray type available in Pythons 2.6, 3.0, and later:
>>> S = 'shrubbery'
>>> L = list(S) # Expand to a list: [...]
>>> L
['s', 'h', 'r', 'u', 'b', 'b', 'e', 'r', 'y']
>>> L[1] = 'c' # Change it in place
>>> ''.join(L) # Join with empty delimiter
'scrubbery'
>>> B = bytearray(b'spam') # A bytes/list hybrid (ahead)
>>> B.extend(b'eggs') # 'b' needed in 3.X, not 2.X
>>> B # B[i] = ord(c) works here too
bytearray(b'spameggs')
>>> B.decode() # Translate to normal string
'spameggs'
The bytearray supports in-place changes for text, but only for text whose characters
are all at most 8-bits wide (e.g., ASCII). All other strings are still immutable—bytear
ray is a distinct hybrid of immutable bytes strings (whose b'...' syntax is required in
3.X and optional in 2.X) and mutable lists (coded and displayed in []), and we have to
learn more about both these and Unicode text to fully grasp this code.
Type-Specific Methods
Every string operation we’ve studied so far is really a sequence operation—that is, these
operations will work on other sequences in Python as well, including lists and tuples.
In addition to generic sequence operations, though, strings also have operations all
their own, available as methods—functions that are attached to and act upon a specific
object, which are triggered with a call expression.
For example, the string find method is the basic substring search operation (it returns
the offset of the passed-in substring, or −1 if it is not present), and the string replace
method performs global searches and replacements; both act on the subject that they
are attached to and called from:
>>> S = 'Spam'
>>> S.find('pa') # Find the offset of a substring in S
1
>>> S
'Spam'
>>> S.replace('pa', 'XYZ') # Replace occurrences of a string in S with another
'SXYZm'
>>> S
'Spam'
Again, despite the names of these string methods, we are not changing the original
strings here, but creating new strings as the results—because strings are immutable,
this is the only way this can work. String methods are the first line of text-processing
102 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-154-320.jpg)
![tools in Python. Other methods split a string into substrings on a delimiter (handy as
asimpleformofparsing),performcaseconversions,testthecontentofthestring(digits,
letters, and so on), and strip whitespace characters off the ends of the string:
>>> line = 'aaa,bbb,ccccc,dd'
>>> line.split(',') # Split on a delimiter into a list of substrings
['aaa', 'bbb', 'ccccc', 'dd']
>>> S = 'spam'
>>> S.upper() # Upper- and lowercase conversions
'SPAM'
>>> S.isalpha() # Content tests: isalpha, isdigit, etc.
True
>>> line = 'aaa,bbb,ccccc,ddn'
>>> line.rstrip() # Remove whitespace characters on the right side
'aaa,bbb,ccccc,dd'
>>> line.rstrip().split(',') # Combine two operations
['aaa', 'bbb', 'ccccc', 'dd']
Notice the last command here—it strips before it splits because Python runs from left
to right, making a temporary result along the way. Strings also support an advanced
substitution operation known as formatting, available as both an expression (the orig-
inal) and a string method call (new as of 2.6 and 3.0); the second of these allows you
to omit relative argument value numbers as of 2.7 and 3.1:
>>> '%s, eggs, and %s' % ('spam', 'SPAM!') # Formatting expression (all)
'spam, eggs, and SPAM!'
>>> '{0}, eggs, and {1}'.format('spam', 'SPAM!') # Formatting method (2.6+, 3.0+)
'spam, eggs, and SPAM!'
>>> '{}, eggs, and {}'.format('spam', 'SPAM!') # Numbers optional (2.7+, 3.1+)
'spam, eggs, and SPAM!'
Formatting is rich with features, which we’ll postpone discussing until later in this
book, and which tend to matter most when you must generate numeric reports:
>>> '{:,.2f}'.format(296999.2567) # Separators, decimal digits
'296,999.26'
>>> '%.2f | %+05d' % (3.14159, −42) # Digits, padding, signs
'3.14 | −0042'
One note here: although sequence operations are generic, methods are not—although
some types share some method names, string method operations generally work only
on strings, and nothing else. As a rule of thumb, Python’s toolset is layered: generic
operations that span multiple types show up as built-in functions or expressions (e.g.,
len(X), X[0]), but type-specific operations are method calls (e.g., aString.upper()).
Finding the tools you need among all these categories will become more natural as you
use Python more, but the next section gives a few tips you can use right now.
Strings | 103](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-155-320.jpg)
![Getting Help
The methods introduced in the prior section are a representative, but small, sample of
what is available for string objects. In general, this book is not exhaustive in its look at
object methods. For more details, you can always call the built-in dir function. This
function lists variables assigned in the caller’s scope when called with no argument;
more usefully, it returns a list of all the attributes available for any object passed to it.
Because methods are function attributes, they will show up in this list. Assuming S is
still the string, here are its attributes on Python 3.3 (Python 2.X varies slightly):
>>> dir(S)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__',
'__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count',
'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index',
'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex',
'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
You probably won’t care about the names with double underscores in this list until later
in the book, when we study operator overloading in classes—they represent the im-
plementation of the string object and are available to support customization. The
__add__ method of strings, for example, is what really performs concatenation; Python
maps the first of the following to the second internally, though you shouldn’t usually
use the second form yourself (it’s less intuitive, and might even run slower):
>>> S + 'NI!'
'spamNI!'
>>> S.__add__('NI!')
'spamNI!'
In general, leading and trailing double underscores is the naming pattern Python uses
for implementation details. The names without the underscores in this list are the call-
able methods on string objects.
The dir function simply gives the methods’ names. To ask what they do, you can pass
them to the help function:
>>> help(S.replace)
Help on built-in function replace:
replace(...)
S.replace(old, new[, count]) -> str
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
104 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-156-320.jpg)
![bytes strings for raw binary data. In Python 2.X, normal files’ content is str bytes, and
a special codecs module handles Unicode and represents content with the unicode type.
We’ll meet Unicode again in the files coverage later in this chapter, but save the rest of
the Unicode story for later in this book. It crops up briefly in a Chapter 25 example in
conjunction with currency symbols, but for the most part is postponed until this book’s
advanced topics part. Unicode is crucial in some domains, but many programmers can
get by with just a passing acquaintance. If your data is all ASCII text, the string and file
stories are largely the same in 2.X and 3.X. And if you’re new to programming, you can
safely defer most Unicode details until you’ve mastered string basics.
Pattern Matching
One point worth noting before we move on is that none of the string object’s own
methods support pattern-based text processing. Text pattern matching is an advanced
tool outside this book’s scope, but readers with backgrounds in other scripting lan-
guages may be interested to know that to do pattern matching in Python, we import a
module called re. This module has analogous calls for searching, splitting, and re-
placement, but because we can use patterns to specify substrings, we can be much more
general:
>>> import re
>>> match = re.match('Hello[ t]*(.*)world', 'Hello Python world')
>>> match.group(1)
'Python '
This example searches for a substring that begins with the word “Hello,” followed by
zero or more tabs or spaces, followed by arbitrary characters to be saved as a matched
group, terminated by the word “world.” If such a substring is found, portions of the
substring matched by parts of the pattern enclosed in parentheses are available as
groups.Thefollowingpattern,forexample,picksoutthreegroupsseparatedbyslashes,
and is similar to splitting by an alternatives pattern:
>>> match = re.match('[/:](.*)[/:](.*)[/:](.*)', '/usr/home:lumberjack')
>>> match.groups()
('usr', 'home', 'lumberjack')
>>> re.split('[/:]', '/usr/home/lumberjack')
['', 'usr', 'home', 'lumberjack']
Pattern matching is an advanced text-processing tool by itself, but there is also support
in Python for even more advanced text and language processing, including XML and
HTML parsing and natural language analysis. We’ll see additional brief examples of
patterns and XML parsing at the end of Chapter 37, but I’ve already said enough about
strings for this tutorial, so let’s move on to the next type.
108 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-160-320.jpg)
![Lists
The Python list object is the most general sequence provided by the language. Lists are
positionally ordered collections of arbitrarily typed objects, and they have no fixed size.
They are also mutable—unlike strings, lists can be modified in place by assignment to
offsets as well as a variety of list method calls. Accordingly, they provide a very flexible
tool for representing arbitrary collections—lists of files in a folder, employees in a
company, emails in your inbox, and so on.
Sequence Operations
Because they are sequences, lists support all the sequence operations we discussed for
strings; the only difference is that the results are usually lists instead of strings. For
instance, given a three-item list:
>>> L = [123, 'spam', 1.23] # A list of three different-type objects
>>> len(L) # Number of items in the list
3
we can index, slice, and so on, just as for strings:
>>> L[0] # Indexing by position
123
>>> L[:-1] # Slicing a list returns a new list
[123, 'spam']
>>> L + [4, 5, 6] # Concat/repeat make new lists too
[123, 'spam', 1.23, 4, 5, 6]
>>> L * 2
[123, 'spam', 1.23, 123, 'spam', 1.23]
>>> L # We're not changing the original list
[123, 'spam', 1.23]
Type-Specific Operations
Python’s lists may be reminiscent of arrays in other languages, but they tend to be more
powerful. For one thing, they have no fixed type constraint—the list we just looked at,
for example, contains three objects of completely different types (an integer, a string,
and a floating-point number). Further, lists have no fixed size. That is, they can grow
and shrink on demand, in response to list-specific operations:
>>> L.append('NI') # Growing: add object at end of list
>>> L
[123, 'spam', 1.23, 'NI']
>>> L.pop(2) # Shrinking: delete an item in the middle
1.23
>>> L # "del L[2]" deletes from a list too
[123, 'spam', 'NI']
Lists | 109](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-161-320.jpg)
![Here, the list append method expands the list’s size and inserts an item at the end; the
pop method (or an equivalent del statement) then removes an item at a given offset,
causing the list to shrink. Other list methods insert an item at an arbitrary position
(insert), remove a given item by value (remove), add multiple items at the end
(extend), and so on. Because lists are mutable, most list methods also change the list
object in place, instead of creating a new one:
>>> M = ['bb', 'aa', 'cc']
>>> M.sort()
>>> M
['aa', 'bb', 'cc']
>>> M.reverse()
>>> M
['cc', 'bb', 'aa']
The list sort method here, for example, orders the list in ascending fashion by default,
and reverse reverses it—in both cases, the methods modify the list directly.
Bounds Checking
Although lists have no fixed size, Python still doesn’t allow us to reference items that
are not present. Indexing off the end of a list is always a mistake, but so is assigning off
the end:
>>> L
[123, 'spam', 'NI']
>>> L[99]
...error text omitted...
IndexError: list index out of range
>>> L[99] = 1
...error text omitted...
IndexError: list assignment index out of range
This is intentional, as it’s usually an error to try to assign off the end of a list (and a
particularly nasty one in the C language, which doesn’t do as much error checking as
Python). Rather than silently growing the list in response, Python reports an error. To
grow a list, we call list methods such as append instead.
Nesting
One nice feature of Python’s core data types is that they support arbitrary nesting—we
can nest them in any combination, and as deeply as we like. For example, we can have
a list that contains a dictionary, which contains another list, and so on. One immediate
application of this feature is to represent matrixes, or “multidimensional arrays” in
Python. A list with nested lists will do the job for basic applications (you’ll get “...”
continuation-line prompts on lines 2 and 3 of the following in some interfaces, but not
in IDLE):
110 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-162-320.jpg)
![>>> M = [[1, 2, 3], # A 3 × 3 matrix, as nested lists
[4, 5, 6], # Code can span lines if bracketed
[7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Here, we’ve coded a list that contains three other lists. The effect is to represent a
3 × 3 matrix of numbers. Such a structure can be accessed in a variety of ways:
>>> M[1] # Get row 2
[4, 5, 6]
>>> M[1][2] # Get row 2, then get item 3 within the row
6
The first operation here fetches the entire second row, and the second grabs the third
item within that row (it runs left to right, like the earlier string strip and split). Stringing
together index operations takes us deeper and deeper into our nested-object structure.3
Comprehensions
In addition to sequence operations and list methods, Python includes a more advanced
operation known as a list comprehension expression, which turns out to be a powerful
way to process structures like our matrix. Suppose, for instance, that we need to extract
the second column of our sample matrix. It’s easy to grab rows by simple indexing
because the matrix is stored by rows, but it’s almost as easy to get a column with a list
comprehension:
>>> col2 = [row[1] for row in M] # Collect the items in column 2
>>> col2
[2, 5, 8]
>>> M # The matrix is unchanged
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
List comprehensions derive from set notation; they are a way to build a new list by
running an expression on each item in a sequence, one at a time, from left to right. List
comprehensions are coded in square brackets (to tip you off to the fact that they make
a list) and are composed of an expression and a looping construct that share a variable
name (row, here). The preceding list comprehension means basically what it says: “Give
me row[1] for each row in matrix M, in a new list.” The result is a new list containing
column 2 of the matrix.
List comprehensions can be more complex in practice:
3. This matrix structure works for small-scale tasks, but for more serious number crunching you will
probably want to use one of the numeric extensions to Python, such as the open source NumPy and
SciPy systems. Such tools can store and process large matrixes much more efficiently than our nested list
structure. NumPy has been said to turn Python into the equivalent of a free and more powerful version
of the Matlab system, and organizations such as NASA, Los Alamos, JPL, and many others use this tool
for scientific and financial tasks. Search the Web for more details.
Lists | 111](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-163-320.jpg)
![>>> [row[1] + 1 for row in M] # Add 1 to each item in column 2
[3, 6, 9]
>>> [row[1] for row in M if row[1] % 2 == 0] # Filter out odd items
[2, 8]
The first operation here, for instance, adds 1 to each item as it is collected, and the
second uses an if clause to filter odd numbers out of the result using the % modulus
expression (remainder of division). List comprehensions make new lists of results, but
they can be used to iterate over any iterable object—a term we’ll flesh out later in this
preview. Here, for instance, we use list comprehensions to step over a hardcoded list
of coordinates and a string:
>>> diag = [M[i][i] for i in [0, 1, 2]] # Collect a diagonal from matrix
>>> diag
[1, 5, 9]
>>> doubles = [c * 2 for c in 'spam'] # Repeat characters in a string
>>> doubles
['ss', 'pp', 'aa', 'mm']
These expressions can also be used to collect multiple values, as long as we wrap those
values in a nested collection. The following illustrates using range—a built-in that gen-
erates successive integers, and requires a surrounding list to display all its values in
3.X only (2.X makes a physical list all at once):
>>> list(range(4)) # 0..3 (list() required in 3.X)
[0, 1, 2, 3]
>>> list(range(−6, 7, 2)) # −6 to +6 by 2 (need list() in 3.X)
[−6, −4, −2, 0, 2, 4, 6]
>>> [[x ** 2, x ** 3] for x in range(4)] # Multiple values, "if" filters
[[0, 0], [1, 1], [4, 8], [9, 27]]
>>> [[x, x / 2, x * 2] for x in range(−6, 7, 2) if x > 0]
[[2, 1, 4], [4, 2, 8], [6, 3, 12]]
As you can probably tell, list comprehensions, and relatives like the map and filter
built-in functions, are too involved to cover more formally in this preview chapter. The
main point of this brief introduction is to illustrate that Python includes both simple
and advanced tools in its arsenal. List comprehensions are an optional feature, but they
tend to be very useful in practice and often provide a substantial processing speed
advantage. They also work on any type that is a sequence in Python, as well as some
types that are not. You’ll hear much more about them later in this book.
As a preview, though, you’ll find that in recent Pythons, comprehension syntax has
been generalized for other roles: it’s not just for making lists today. For example, en-
closing a comprehension in parentheses can also be used to create generators that pro-
duce results on demand. To illustrate, the sum built-in sums items in a sequence—in
this example, summing all items in our matrix’s rows on request:
>>> G = (sum(row) for row in M) # Create a generator of row sums
>>> next(G) # iter(G) not required here
112 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-164-320.jpg)
![6
>>> next(G) # Run the iteration protocol next()
15
>>> next(G)
24
The map built-in can do similar work, by generating the results of running items through
a function, one at a time and on request. Like range, wrapping it in list forces it to
return all its values in Python 3.X; this isn’t needed in 2.X where map makes a list of
results all at once instead, and is not needed in other contexts that iterate automatically,
unless multiple scans or list-like behavior is also required:
>>> list(map(sum, M)) # Map sum over items in M
[6, 15, 24]
In Python 2.7 and 3.X, comprehension syntax can also be used to create sets and
dictionaries:
>>> {sum(row) for row in M} # Create a set of row sums
{24, 6, 15}
>>> {i : sum(M[i]) for i in range(3)} # Creates key/value table of row sums
{0: 6, 1: 15, 2: 24}
In fact, lists, sets, dictionaries, and generators can all be built with comprehensions in
3.X and 2.7:
>>> [ord(x) for x in 'spaam'] # List of character ordinals
[115, 112, 97, 97, 109]
>>> {ord(x) for x in 'spaam'} # Sets remove duplicates
{112, 97, 115, 109}
>>> {x: ord(x) for x in 'spaam'} # Dictionary keys are unique
{'p': 112, 'a': 97, 's': 115, 'm': 109}
>>> (ord(x) for x in 'spaam') # Generator of values
<generator object <genexpr> at 0x000000000254DAB0>
To understand objects like generators, sets, and dictionaries, though, we must move
ahead.
Dictionaries
Python dictionaries are something completely different (Monty Python reference in-
tended)—they are not sequences at all, but are instead known as mappings. Mappings
are also collections of other objects, but they store objects by key instead of by relative
position. In fact, mappings don’t maintain any reliable left-to-right order; they simply
map keys to associated values. Dictionaries, the only mapping type in Python’s core
objects set, are also mutable: like lists, they may be changed in place and can grow and
shrink on demand. Also like lists, they are a flexible tool for representing collections,
but their more mnemonic keys are better suited when a collection’s items are named or
labeled—fields of a database record, for example.
Dictionaries | 113](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-165-320.jpg)
![Mapping Operations
When written as literals, dictionaries are coded in curly braces and consist of a series
of “key: value” pairs. Dictionaries are useful anytime we need to associate a set of values
with keys—to describe the properties of something, for instance. As an example, con-
sider the following three-item dictionary (with keys “food,” “quantity,” and “color,”
perhaps the details of a hypothetical menu item?):
>>> D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'}
We can index this dictionary by key to fetch and change the keys’ associated values.
The dictionary index operation uses the same syntax as that used for sequences, but
the item in the square brackets is a key, not a relative position:
>>> D['food'] # Fetch value of key 'food'
'Spam'
>>> D['quantity'] += 1 # Add 1 to 'quantity' value
>>> D
{'color': 'pink', 'food': 'Spam', 'quantity': 5}
Although the curly-braces literal form does see use, it is perhaps more common to see
dictionaries built up in different ways (it’s rare to know all your program’s data before
your program runs). The following code, for example, starts with an empty dictionary
and fills it out one key at a time. Unlike out-of-bounds assignments in lists, which are
forbidden, assignments to new dictionary keys create those keys:
>>> D = {}
>>> D['name'] = 'Bob' # Create keys by assignment
>>> D['job'] = 'dev'
>>> D['age'] = 40
>>> D
{'age': 40, 'job': 'dev', 'name': 'Bob'}
>>> print(D['name'])
Bob
Here, we’re effectively using dictionary keys as field names in a record that describes
someone. In other applications, dictionaries can also be used to replace searching op-
erations—indexing a dictionary by key is often the fastest way to code a search in
Python.
As we’ll learn later, we can also make dictionaries by passing to the dict type name
either keyword arguments (a special name=value syntax in function calls), or the result
of zipping together sequences of keys and values obtained at runtime (e.g., from files).
Both the following make the same dictionary as the prior example and its equivalent
{} literal form, though the first tends to make for less typing:
>>> bob1 = dict(name='Bob', job='dev', age=40) # Keywords
>>> bob1
{'age': 40, 'name': 'Bob', 'job': 'dev'}
114 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-166-320.jpg)
![>>> bob2 = dict(zip(['name', 'job', 'age'], ['Bob', 'dev', 40])) # Zipping
>>> bob2
{'job': 'dev', 'name': 'Bob', 'age': 40}
Notice how the left-to-right order of dictionary keys is scrambled. Mappings are not
positionally ordered, so unless you’re lucky, they’ll come back in a different order than
you typed them. The exact order may vary per Python, but you shouldn’t depend on
it, and shouldn’t expect yours to match that in this book.
Nesting Revisited
In the prior example, we used a dictionary to describe a hypothetical person, with three
keys. Suppose, though, that the information is more complex. Perhaps we need to
record a first name and a last name, along with multiple job titles. This leads to another
application of Python’s object nesting in action. The following dictionary, coded all at
once as a literal, captures more structured information:
>>> rec = {'name': {'first': 'Bob', 'last': 'Smith'},
'jobs': ['dev', 'mgr'],
'age': 40.5}
Here, we again have a three-key dictionary at the top (keys “name,” “jobs,” and “age”),
but the values have become more complex: a nested dictionary for the name to support
multiple parts, and a nested list for the jobs to support multiple roles and future ex-
pansion. We can access the components of this structure much as we did for our list-
based matrix earlier, but this time most indexes are dictionary keys, not list offsets:
>>> rec['name'] # 'name' is a nested dictionary
{'last': 'Smith', 'first': 'Bob'}
>>> rec['name']['last'] # Index the nested dictionary
'Smith'
>>> rec['jobs'] # 'jobs' is a nested list
['dev', 'mgr']
>>> rec['jobs'][-1] # Index the nested list
'mgr'
>>> rec['jobs'].append('janitor') # Expand Bob's job description in place
>>> rec
{'age': 40.5, 'jobs': ['dev', 'mgr', 'janitor'], 'name': {'last': 'Smith',
'first': 'Bob'}}
Notice how the last operation here expands the nested jobs list—because the jobs list
is a separate piece of memory from the dictionary that contains it, it can grow and shrink
freely (object memory layout will be discussed further later in this book).
The real reason for showing you this example is to demonstrate the flexibility of
Python’s core data types. As you can see, nesting allows us to build up complex infor-
mationstructuresdirectlyandeasily.Buildinga similarstructureinalow-levellanguage
like C would be tedious and require much more code: we would have to lay out and
Dictionaries | 115](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-167-320.jpg)
![{'a': 1, 'c': 3, 'b': 2}
>>> D['e'] = 99 # Assigning new keys grows dictionaries
>>> D
{'a': 1, 'c': 3, 'b': 2, 'e': 99}
>>> D['f'] # Referencing a nonexistent key is an error
...error text omitted...
KeyError: 'f'
This is what we want—it’s usually a programming error to fetch something that isn’t
really there. But in some generic programs, we can’t always know what keys will be
present when we write our code. How do we handle such cases and avoid errors? One
solution is to test ahead of time. The dictionary in membership expression allows us
to query the existence of a key and branch on the result with a Python if statement. In
the following, be sure to press Enter twice to run the if interactively after typing its
code (as explained in Chapter 3, an empty line means “go” at the interactive prompt),
and just as for the earlier multiline dictionaries and lists, the prompt changes to “...”
on some interfaces for lines two and beyond:
>>> 'f' in D
False
>>> if not 'f' in D: # Python's sole selection statement
print('missing')
missing
This book has more to say about the if statement in later chapters, but the form we’re
using here is straightforward: it consists of the word if, followed by an expression that
is interpreted as a true or false result, followed by a block of code to run if the test is
true. In its full form, the if statement can also have an else clause for a default case,
and one or more elif (“else if”) clauses for other tests. It’s the main selection statement
tool in Python; along with both its ternary if/else expression cousin (which we’ll meet
in a moment) and the if comprehension filter lookalike we saw earlier, it’s the way we
code the logic of choices and decisions in our scripts.
If you’ve used some other programming languages in the past, you might be wondering
how Python knows when the if statement ends. I’ll explain Python’s syntax rules in
depth in later chapters, but in short, if you have more than one action to run in a
statement block, you simply indent all their statements the same way—this both pro-
motes readable code and reduces the number of characters you have to type:
>>> if not 'f' in D:
print('missing')
print('no, really...') # Statement blocks are indented
missing
no, really...
Dictionaries | 117](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-169-320.jpg)
![Besides the in test, there are a variety of ways to avoid accessing nonexistent keys in
the dictionaries we create: the get method, a conditional index with a default; the
Python 2.X has_key method, an in work-alike that is no longer available in 3.X; the
try statement, a tool we’ll first meet in Chapter 10 that catches and recovers from
exceptions altogether; and the if/else ternary (three-part) expression, which is essen-
tially an if statement squeezed onto a single line. Here are a few examples:
>>> value = D.get('x', 0) # Index but with a default
>>> value
0
>>> value = D['x'] if 'x' in D else 0 # if/else expression form
>>> value
0
We’ll save the details on such alternatives until a later chapter. For now, let’s turn to
another dictionary method’s role in a common use case.
Sorting Keys: for Loops
As mentioned earlier, because dictionaries are not sequences, they don’t maintain any
dependable left-to-right order. If we make a dictionary and print it back, its keys may
come back in a different order than that in which we typed them, and may vary per
Python version and other variables:
>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'a': 1, 'c': 3, 'b': 2}
What do we do, though, if we do need to impose an ordering on a dictionary’s items?
One common solution is to grab a list of keys with the dictionary keys method, sort
that with the list sort method, and then step through the result with a Python for loop
(as for if, be sure to press the Enter key twice after coding the following for loop, and
omit the outer parenthesis in the print in Python 2.X):
>>> Ks = list(D.keys()) # Unordered keys list
>>> Ks # A list in 2.X, "view" in 3.X: use list()
['a', 'c', 'b']
>>> Ks.sort() # Sorted keys list
>>> Ks
['a', 'b', 'c']
>>> for key in Ks: # Iterate though sorted keys
print(key, '=>', D[key]) # <== press Enter twice here (3.X print)
a => 1
b => 2
c => 3
This is a three-step process, although, as we’ll see in later chapters, in recent versions
of Python it can be done in one step with the newer sorted built-in function. The
118 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-170-320.jpg)
![sorted call returns the result and sorts a variety of object types, in this case sorting
dictionary keys automatically:
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> for key in sorted(D):
print(key, '=>', D[key])
a => 1
b => 2
c => 3
Besides showcasing dictionaries, this use case serves to introduce the Python for loop.
The for loop is a simple and efficient way to step through all the items in a sequence
and run a block of code for each item in turn. A user-defined loop variable (key, here)
is used to reference the current item each time through. The net effect in our example
is to print the unordered dictionary’s keys and values, in sorted-key order.
The for loop, and its more general colleague the while loop, are the main ways we code
repetitive tasks as statements in our scripts. Really, though, the for loop, like its relative
the list comprehension introduced earlier, is a sequence operation. It works on any
object that is a sequence and, like the list comprehension, even on some things that are
not. Here, for example, it is stepping across the characters in a string, printing the
uppercase version of each as it goes:
>>> for c in 'spam':
print(c.upper())
S
P
A
M
Python’s while loop is a more general sort of looping tool; it’s not limited to stepping
across sequences, but generally requires more code to do so:
>>> x = 4
>>> while x > 0:
print('spam!' * x)
x -= 1
spam!spam!spam!spam!
spam!spam!spam!
spam!spam!
spam!
We’ll discuss looping statements, syntax, and tools in depth later in the book. First,
though, I need to confess that this section has not been as forthcoming as it might have
been. Really, the for loop, and all its cohorts that step through objects from left to right,
are not just sequence operations, they are iterable operations—as the next section de-
scribes.
Dictionaries | 119](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-171-320.jpg)
![Iteration and Optimization
If the last section’s for loop looks like the list comprehension expression introduced
earlier, it should: both are really general iteration tools. In fact, both will work on any
iterable object that follows the iteration protocol—pervasive ideas in Python that un-
derlie all its iteration tools.
In a nutshell, an object is iterable if it is either a physically stored sequence in memory,
or an object that generates one item at a time in the context of an iteration operation
—a sort of “virtual” sequence. More formally, both types of objects are considered
iterable because they support the iteration protocol—they respond to the iter call with
an object that advances in response to next calls and raises an exception when finished
producing values.
The generator comprehension expression we saw earlier is such an object: its values
aren’t stored in memory all at once, but are produced as requested, usually by iteration
tools. Python file objects similarly iterate line by line when used by an iteration tool:
file content isn’t in a list, it’s fetched on demand. Both are iterable objects in Python—
a category that expands in 3.X to include core tools like range and map.
I’ll have more to say about the iteration protocol later in this book. For now, keep in
mind that every Python tool that scans an object from left to right uses the iteration
protocol. This is why the sorted call used in the prior section works on the dictionary
directly—we don’t have to call the keys method to get a sequence because dictionaries
are iterable objects, with a next that returns successive keys.
It may also help you to see that any list comprehension expression, such as this one,
which computes the squares of a list of numbers:
>>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
>>> squares
[1, 4, 9, 16, 25]
can always be coded as an equivalent for loop that builds the result list manually by
appending as it goes:
>>> squares = []
>>> for x in [1, 2, 3, 4, 5]: # This is what a list comprehension does
squares.append(x ** 2) # Both run the iteration protocol internally
>>> squares
[1, 4, 9, 16, 25]
Both tools leverage the iteration protocol internally and produce the same result. The
list comprehension, though, and related functional programming tools like map and
filter, will often run faster than a for loop today on some types of code (perhaps even
twice as fast)—a property that could matter in your programs for large data sets. Having
said that, though, I should point out that performance measures are tricky business in
Python because it optimizes so much, and they may vary from release to release.
120 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-172-320.jpg)
![A major rule of thumb in Python is to code for simplicity and readability first and worry
about performance later, after your program is working, and after you’ve proved that
there is a genuine performance concern. More often than not, your code will be quick
enough as it is. If you do need to tweak code for performance, though, Python includes
tools to help you out, including the time and timeit modules for timing the speed of
alternatives, and the profile module for isolating bottlenecks.
You’ll find more on these later in this book (see especially Chapter 21’s benchmarking
case study) and in the Python manuals. For the sake of this preview, let’s move ahead
to the next core data type.
Tuples
The tuple object (pronounced “toople” or “tuhple,” depending on whom you ask) is
roughly like a list that cannot be changed—tuples are sequences, like lists, but they are
immutable, like strings. Functionally, they’re used to represent fixed collections of
items: the components of a specific calendar date, for instance. Syntactically, they are
normally coded in parentheses instead of square brackets, and they support arbitrary
types, arbitrary nesting, and the usual sequence operations:
>>> T = (1, 2, 3, 4) # A 4-item tuple
>>> len(T) # Length
4
>> T + (5, 6) # Concatenation
(1, 2, 3, 4, 5, 6)
>>> T[0] # Indexing, slicing, and more
1
Tuples also have type-specific callable methods as of Python 2.6 and 3.0, but not nearly
as many as lists:
>>> T.index(4) # Tuple methods: 4 appears at offset 3
3
>>> T.count(4) # 4 appears once
1
The primary distinction for tuples is that they cannot be changed once created. That
is, they are immutable sequences (one-item tuples like the one here require a trailing
comma):
>>> T[0] = 2 # Tuples are immutable
...error text omitted...
TypeError: 'tuple' object does not support item assignment
>>> T = (2,) + T[1:] # Make a new tuple for a new value
>>> T
(2, 2, 3, 4)
Tuples | 121](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-173-320.jpg)
![Like lists and dictionaries, tuples support mixed types and nesting, but they don’t grow
and shrink because they are immutable (the parentheses enclosing a tuple’s items can
usually be omitted, as done here):
>>> T = 'spam', 3.0, [11, 22, 33]
>>> T[1]
3.0
>>> T[2][1]
22
>>> T.append(4)
AttributeError: 'tuple' object has no attribute 'append'
Why Tuples?
So, why have a type that is like a list, but supports fewer operations? Frankly, tuples
are not generally used as often as lists in practice, but their immutability is the whole
point. If you pass a collection of objects around your program as a list, it can be changed
anywhere; if you use a tuple, it cannot. That is, tuples provide a sort of integrity con-
straint that is convenient in programs larger than those we’ll write here. We’ll talk more
about tuples later in the book, including an extension that builds upon them called
named tuples. For now, though, let’s jump ahead to our last major core type: the file.
Files
File objects are Python code’s main interface to external files on your computer. They
can be used to read and write text memos, audio clips, Excel documents, saved email
messages, and whatever else you happen to have stored on your machine. Files are a
core type, but they’re something of an oddball—there is no specific literal syntax for
creating them. Rather, to create a file object, you call the built-in open function, passing
in an external filename and an optional processing mode as strings.
For example, to create a text output file, you would pass in its name and the 'w' pro-
cessing mode string to write data:
>>> f = open('data.txt', 'w') # Make a new file in output mode ('w' is write)
>>> f.write('Hellon') # Write strings of characters to it
6
>>> f.write('worldn') # Return number of items written in Python 3.X
6
>>> f.close() # Close to flush output buffers to disk
This creates a file in the current directory and writes text to it (the filename can be a
full directory path if you need to access a file elsewhere on your computer). To read
back what you just wrote, reopen the file in 'r' processing mode, for reading text input
—this is the default if you omit the mode in the call. Then read the file’s content into
a string, and display it. A file’s contents are always a string in your script, regardless of
the type of data the file contains:
122 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-174-320.jpg)
![>>> f = open('data.txt') # 'r' (read) is the default processing mode
>>> text = f.read() # Read entire file into a string
>>> text
'Hellonworldn'
>>> print(text) # print interprets control characters
Hello
world
>>> text.split() # File content is always a string
['Hello', 'world']
Other file object methods support additional features we don’t have time to cover here.
For instance, file objects provide more ways of reading and writing (read accepts an
optional maximum byte/character size, readline reads one line at a time, and so on),
as well as other tools (seek moves to a new file position). As we’ll see later, though, the
best way to read a file today is to not read it at all—files provide an iterator that auto-
matically reads line by line in for loops and other contexts:
>>> for line in open('data.txt'): print(line)
We’ll meet the full set of file methods later in this book, but if you want a quick preview
now, run a dir call on any open file and a help on any of the method names that come
back:
>>> dir(f)
[ ...many names omitted...
'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush',
'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable',
'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable',
'write', 'writelines']
>>>help(f.seek)
...try it and see...
Binary Bytes Files
The prior section’s examples illustrate file basics that suffice for many roles. Techni-
cally, though, they rely on either the platform’s Unicode encoding default in Python
3.X, or the 8-bit byte nature of files in Python 2.X. Text files always encode strings in
3.X, and blindly write string content in 2.X. This is irrelevant for the simple ASCII data
used previously, which maps to and from file bytes unchanged. But for richer types of
data, file interfaces can vary depending on both content and the Python line you use.
As hinted when we met strings earlier, Python 3.X draws a sharp distinction between
text and binary data in files: text files represent content as normal str strings and per-
form Unicode encoding and decoding automatically when writing and reading data,
while binary files represent content as a special bytes string and allow you to access file
content unaltered. Python 2.X supports the same dichotomy, but doesn’t impose it as
rigidly, and its tools differ.
Files | 123](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-175-320.jpg)
![For example, binary files are useful for processing media, accessing data created by C
programs, and so on. To illustrate, Python’s struct module can both create and unpack
packed binary data—raw bytes that record values that are not Python objects—to be
written to a file in binary mode. We’ll study this technique in detail later in the book,
but the concept is simple: the following creates a binary file in Python 3.X (binary files
work the same in 2.X, but the “b” string literal prefix isn’t required and won’t be dis-
played):
>>> import struct
>>> packed = struct.pack('>i4sh', 7, b'spam', 8) # Create packed binary data
>>> packed # 10 bytes, not objects or text
b'x00x00x00x07spamx00x08'
>>>
>>> file = open('data.bin', 'wb') # Open binary output file
>>> file.write(packed) # Write packed binary data
10
>>> file.close()
Reading binary data back is essentially symmetric; not all programs need to tread so
deeply into the low-level realm of bytes, but binary files make this easy in Python:
>>> data = open('data.bin', 'rb').read() # Open/read binary data file
>>> data # 10 bytes, unaltered
b'x00x00x00x07spamx00x08'
>>> data[4:8] # Slice bytes in the middle
b'spam'
>>> list(data) # A sequence of 8-bit bytes
[0, 0, 0, 7, 115, 112, 97, 109, 0, 8]
>>> struct.unpack('>i4sh', data) # Unpack into objects again
(7, b'spam', 8)
Unicode Text Files
Text files are used to process all sorts of text-based data, from memos to email content
to JSON and XML documents. In today’s broader interconnected world, though, we
can’t really talk about text without also asking “what kind?”—you must also know the
text’s Unicode encoding type if either it differs from your platform’s default, or you
can’t rely on that default for data portability reasons.
Luckily, this is easier than it may sound. To access files containing non-ASCII Unicode
text of the sort introduced earlier in this chapter, we simply pass in an encoding name
if the text in the file doesn’t match the default encoding for our platform. In this mode,
Python text files automatically encode on writes and decode on reads per the encoding
scheme name you provide. In Python 3.X:
>>> S = 'spxc4m' # Non-ASCII Unicode text
>>> S
'spÄm'
>>> S[2] # Sequence of characters
'Ä'
>>> file = open('unidata.txt', 'w', encoding='utf-8') # Write/encode UTF-8 text
124 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-176-320.jpg)
![{'p', 's'}
>>> X > Y # Superset
False
>>> {n ** 2 for n in [1, 2, 3, 4]} # Set comprehensions in 3.X and 2.7
{16, 1, 4, 9}
Even less mathematically inclined programmers often find sets useful for common tasks
such as filtering out duplicates, isolating differences, and performing order-neutral
equality tests without sorting—in lists, strings, and all other iterable objects:
>>> list(set([1, 2, 1, 3, 1])) # Filtering out duplicates (possibly reordered)
[1, 2, 3]
>>> set('spam') - set('ham') # Finding differences in collections
{'p', 's'}
>>> set('spam') == set('asmp') # Order-neutral equality tests (== is False)
True
Sets also support in membership tests, though all other collection types in Python do
too:
>>> 'p' in set('spam'), 'p' in 'spam', 'ham' in ['eggs', 'spam', 'ham']
(True, True, True)
In addition, Python recently grew a few new numeric types: decimal numbers, which
are fixed-precision floating-point numbers, and fraction numbers, which are rational
numbers with both a numerator and a denominator. Both can be used to work around
the limitations and inherent inaccuracies of floating-point math:
>>> 1 / 3 # Floating-point (add a .0 in Python 2.X)
0.3333333333333333
>>> (2/3) + (1/2)
1.1666666666666665
>>> import decimal # Decimals: fixed precision
>>> d = decimal.Decimal('3.141')
>>> d + 1
Decimal('4.141')
>>> decimal.getcontext().prec = 2
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.33')
>>> from fractions import Fraction # Fractions: numerator+denominator
>>> f = Fraction(2, 3)
>>> f + 1
Fraction(5, 3)
>>> f + Fraction(1, 2)
Fraction(7, 6)
Python also comes with Booleans (with predefined True and False objects that are es-
sentially just the integers 1 and 0 with custom display logic), and it has long supported
a special placeholder object called None commonly used to initialize names and objects:
Other Core Types | 127](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-179-320.jpg)
![>>> 1 > 2, 1 < 2 # Booleans
(False, True)
>>> bool('spam') # Object's Boolean value
True
>>> X = None # None placeholder
>>> print(X)
None
>>> L = [None] * 100 # Initialize a list of 100 Nones
>>> L
[None, None, None, None, None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None, ...a list of 100 Nones...]
How to Break Your Code’s Flexibility
I’ll have more to say about all of Python’s object types later, but one merits special
treatment here. The type object, returned by the type built-in function, is an object that
gives the type of another object; its result differs slightly in 3.X, because types have
merged with classes completely (something we’ll explore in the context of “new-style”
classes in Part VI). Assuming L is still the list of the prior section:
# In Python 2.X:
>>> type(L) # Types: type of L is list type object
<type 'list'>
>>> type(type(L)) # Even types are objects
<type 'type'>
# In Python 3.X:
>>> type(L) # 3.X: types are classes, and vice versa
<class 'list'>
>>> type(type(L)) # See Chapter 32 for more on class types
<class 'type'>
Besides allowing you to explore your objects interactively, the type object in its most
practical application allows code to check the types of the objects it processes. In fact,
there are at least three ways to do so in a Python script:
>>> if type(L) == type([]): # Type testing, if you must...
print('yes')
yes
>>> if type(L) == list: # Using the type name
print('yes')
yes
>>> if isinstance(L, list): # Object-oriented tests
print('yes')
yes
Now that I’ve shown you all these ways to do type testing, however, I am required by
law to tell you that doing so is almost always the wrong thing to do in a Python program
(and often a sign of an ex-C programmer first starting to use Python!). The reason why
128 | Chapter 4: Introducing Python Object Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-180-320.jpg)
![won’t become completely clear until later in the book, when we start writing larger
code units such as functions, but it’s a (perhaps the) core Python concept. By checking
for specific types in your code, you effectively break its flexibility—you limit it to
working on just one type. Without such tests, your code may be able to work on a
whole range of types.
This is related to the idea of polymorphism mentioned earlier, and it stems from
Python’s lack of type declarations. As you’ll learn, in Python, we code to object inter-
faces (operations supported), not to types. That is, we care what an object does, not
what it is. Not caring about specific types means that code is automatically applicable
to many of them—any object with a compatible interface will work, regardless of its
specific type. Although type checking is supported—and even required in some rare
cases—you’ll see that it’s not usually the “Pythonic” way of thinking. In fact, you’ll
find that polymorphism is probably the key idea behind using Python well.
User-Defined Classes
We’ll study object-oriented programming in Python—an optional but powerful feature
of the language that cuts development time by supporting programming by customi-
zation—in depth later in this book. In abstract terms, though, classes define new types
of objects that extend the core set, so they merit a passing glance here. Say, for example,
that you wish to have a type of object that models employees. Although there is no such
specific core type in Python, the following user-defined class might fit the bill:
>>> class Worker:
def __init__(self, name, pay): # Initialize when created
self.name = name # self is the new object
self.pay = pay
def lastName(self):
return self.name.split()[-1] # Split string on blanks
def giveRaise(self, percent):
self.pay *= (1.0 + percent) # Update pay in place
This class defines a new kind of object that will have name and pay attributes (sometimes
called state information), as well as two bits of behavior coded as functions (normally
called methods). Calling the class like a function generates instances of our new type,
and the class’s methods automatically receive the instance being processed by a given
method call (in the self argument):
>>> bob = Worker('Bob Smith', 50000) # Make two instances
>>> sue = Worker('Sue Jones', 60000) # Each has name and pay attrs
>>> bob.lastName() # Call method: bob is self
'Smith'
>>> sue.lastName() # sue is the self subject
'Jones'
>>> sue.giveRaise(.10) # Updates sue's pay
>>> sue.pay
66000.0
Other Core Types | 129](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-181-320.jpg)
![Table 5-2. Python expression operators and precedence
Operators Description
yield x Generator function send protocol
lambda args: expression Anonymous function generation
x if y else z Ternary selection (x is evaluated only if y is true)
x or y Logical OR (y is evaluated only if x is false)
x and y Logical AND (y is evaluated only if x is true)
not x Logical negation
x in y, x not in y Membership (iterables, sets)
x is y, x is not y Object identity tests
x < y, x <= y, x > y, x >= y
x == y, x != y
Magnitude comparison, set subset and superset;
Value equality operators
x | y Bitwise OR, set union
x ^ y Bitwise XOR, set symmetric difference
x & y Bitwise AND, set intersection
x << y, x >> y Shift x left or right by y bits
x + y
x – y
Addition, concatenation;
Subtraction, set difference
x * y
x % y
x / y, x // y
Multiplication, repetition;
Remainder, format;
Division: true and floor
−x, +x Negation, identity
˜x Bitwise NOT (inversion)
x ** y Power (exponentiation)
x[i] Indexing (sequence, mapping, others)
x[i:j:k] Slicing
x(...) Call (function, method, class, other callable)
x.attr Attribute reference
(...) Tuple, expression, generator expression
[...] List, list comprehension
{...} Dictionary, set, set and dictionary comprehensions
Since this book addresses both Python 2.X and 3.X, here are some notes about version
differences and recent additions related to the operators in Table 5-2:
Numeric Type Basics | 137](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-189-320.jpg)
![• In Python 2.X, value inequality can be written as either X != Y or X <> Y. In Python
3.X, the latter of these options is removed because it is redundant. In either version,
best practice is to use X != Y for all value inequality tests.
• In Python 2.X, a backquotes expression`X` works the same asrepr(X) and converts
objects to display strings. Due to its obscurity, this expression is removed in Python
3.X; use the more readable str and repr built-in functions, described in “Numeric
Display Formats.”
• The X // Y floor division expression always truncates fractional remainders in both
Python 2.X and 3.X. The X / Y expression performs true division in 3.X (retaining
remainders) and classic division in 2.X (truncating for integers). See “Division:
Classic, Floor, and True” on page 146.
• The syntax [...] is used for both list literals and list comprehension expressions.
The latter of these performs an implied loop and collects expression results in a
new list. See Chapter 4, Chapter 14, and Chapter 20 for examples.
• The syntax (...) is used for tuples and expression grouping, as well as generator
expressions—a form of list comprehension that produces results on demand, in-
stead of building a result list. See Chapter 4 and Chapter 20 for examples. The
parentheses may sometimes be omitted in all three contexts.
• The syntax {...} is used for dictionary literals, and in Python 3.X and 2.7 for set
literals and both dictionary and set comprehensions. See the set coverage in this
chapter as well as Chapter 4, Chapter 8, Chapter 14, and Chapter 20 for examples.
• The yield and ternary if/else selection expressions are available in Python 2.5 and
later. The former returns send(...) arguments in generators; the latter is shorthand
for a multiline if statement. yield requires parentheses if not alone on the right
side of an assignment statement.
• Comparison operators may be chained: X < Y < Z produces the same result as X <
Y and Y < Z. See “Comparisons: Normal and Chained” on page 144 for details.
• In recent Pythons, the slice expression X[I:J:K] is equivalent to indexing with a
slice object: X[slice(I, J, K)].
• In Python 2.X, magnitude comparisons of mixed types are allowed, and convert
numbers to a common type, and order other mixed types according to type names.
In Python 3.X, nonnumeric mixed-type magnitude comparisons are not allowed
and raise exceptions; this includes sorts by proxy.
• Magnitude comparisons for dictionaries are also no longer supported in Python
3.X (though equality tests are); comparing sorted(aDict.items()) is one possible
replacement.
We’ll see most of the operators in Table 5-2 in action later; first, though, we need to
take a quick look at the ways these operators may be combined in expressions.
138 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-190-320.jpg)
![Preview: Operator overloading and polymorphism
Although we’re focusing on built-in numbers right now, all Python operators may be
overloaded (i.e., implemented) by Python classes and C extension types to work on
objects you create. For instance, you’ll see later that objects coded with classes may be
added or concatenated with x+y expressions, indexed with x[i] expressions, and so on.
Furthermore, Python itself automatically overloads some operators, such that they
perform different actions depending on the type of built-in objects being processed.
For example, the + operator performs addition when applied to numbers but performs
concatenation when applied to sequence objects such as strings and lists. In fact, + can
mean anything at all when applied to objects you define with classes.
As we saw in the prior chapter, this property is usually called polymorphism—a term
indicating that the meaning of an operation depends on the type of the objects being
operated on. We’ll revisit this concept when we explore functions in Chapter 16, be-
cause it becomes a much more obvious feature in that context.
Numbers in Action
On to the code! Probably the best way to understand numeric objects and expressions
is to see them in action, so with those basics in hand let’s start up the interactive com-
mand line and try some simple but illustrative operations (be sure to see Chapter 3 for
pointers if you need help starting an interactive session).
Variables and Basic Expressions
First of all, let’s exercise some basic math. In the following interaction, we first assign
two variables (a and b) to integers so we can use them later in a larger expression.
Variables are simply names—created by you or Python—that are used to keep track of
information in your program. We’ll say more about this in the next chapter, but in
Python:
• Variables are created when they are first assigned values.
• Variables are replaced with their values when used in expressions.
• Variables must be assigned before they can be used in expressions.
• Variables refer to objects and are never declared ahead of time.
In other words, these assignments cause the variables a and b to spring into existence
automatically:
% python
>>> a = 3 # Name created: not declared ahead of time
>>> b = 4
I’ve also used a comment here. Recall that in Python code, text after a # mark and
continuing to the end of the line is considered to be a comment and is ignored by
Numbers in Action | 141](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-193-320.jpg)
![Python. Comments are a way to write human-readable documentation for your code,
and an important part of programming. I’ve added them to most of this book’s exam-
ples to help explain the code. In the next part of the book, we’ll meet a related but more
functional feature—documentation strings—that attaches the text of your comments
to objects so it’s available after your code is loaded.
Because code you type interactively is temporary, though, you won’t normally write
comments in this context. If you’re working along, this means you don’t need to type
any of the comment text from the # through to the end of the line; it’s not a required
part of the statements we’re running this way.
Now, let’s use our new integer objects in some expressions. At this point, the values of
a and b are still 3 and 4, respectively. Variables like these are replaced with their values
whenever they’re used inside an expression, and the expression results are echoed back
immediately when we’re working interactively:
>>> a + 1, a − 1 # Addition (3 + 1), subtraction (3 − 1)
(4, 2)
>>> b * 3, b / 2 # Multiplication (4 * 3), division (4 / 2)
(12, 2.0)
>>> a % 2, b ** 2 # Modulus (remainder), power (4 ** 2)
(1, 16)
>>> 2 + 4.0, 2.0 ** b # Mixed-type conversions
(6.0, 16.0)
Technically, the results being echoed back here are tuples of two values because the
lines typed at the prompt contain two expressions separated by commas; that’s why
the results are displayed in parentheses (more on tuples later). Note that the expressions
work because the variables a and b within them have been assigned values. If you use
a different variable that has not yet been assigned, Python reports an error rather than
filling in some default value:
>>> c * 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined
You don’t need to predeclare variables in Python, but they must have been assigned at
least once before you can use them. In practice, this means you have to initialize coun-
ters to zero before you can add to them, initialize lists to an empty list before you can
append to them, and so on.
Here are two slightly larger expressions to illustrate operator grouping and more about
conversions, and preview a difference in the division operator in Python 3.X and 2.X:
>>> b / 2 + a # Same as ((4 / 2) + 3) [use 2.0 in 2.X]
5.0
>>> b / (2.0 + a) # Same as (4 / (2.0 + 3)) [use print before 2.7]
0.8
In the first expression, there are no parentheses, so Python automatically groups the
components according to its precedence rules—because / is lower in Table 5-2 than
142 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-194-320.jpg)
![>>> random.randint(1, 10)
5
>>> random.randint(1, 10)
9
This module can also choose an item at random from a sequence, and shuffle a list of
items randomly:
>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Holy Grail'
>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Life of Brian'
>>> suits = ['hearts', 'clubs', 'diamonds', 'spades']
>>> random.shuffle(suits)
>>> suits
['spades', 'hearts', 'diamonds', 'clubs']
>>> random.shuffle(suits)
>>> suits
['clubs', 'diamonds', 'hearts', 'spades']
Though we’d need additional code to make this more tangible here, the random module
can be useful for shuffling cards in games, picking images at random in a slideshow
GUI, performing statistical simulations, and much more. We’ll deploy it again later in
this book (e.g., in Chapter 20’s permutations case study), but for more details, see
Python’s library manual.
Other Numeric Types
So far in this chapter, we’ve been using Python’s core numeric types—integer, floating
point, and complex. These will suffice for most of the number crunching that most
programmers will ever need to do. Python comes with a handful of more exotic numeric
types, though, that merit a brief look here.
Decimal Type
Python 2.4 introduced a new core numeric type: the decimal object, formally known
as Decimal. Syntactically, you create decimals by calling a function within an imported
module, rather than running a literal expression. Functionally, decimals are like float-
ing-point numbers, but they have a fixed number of decimal points. Hence, decimals
are fixed-precision floating-point values.
For example, with decimals, we can have a floating-point value that always retains just
two decimal digits. Furthermore, we can specify how to round or truncate the extra
decimal digits beyond the object’s cutoff. Although it generally incurs a performance
penalty compared to the normal floating-point type, the decimal type is well suited to
representing fixed-precision quantities like sums of money and can help you achieve
better numeric accuracy.
Other Numeric Types | 157](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-209-320.jpg)
![Because sets are collections of other objects, they share some behavior with objects
such as lists and dictionaries that are outside the scope of this chapter. For example,
sets are iterable, can grow and shrink on demand, and may contain a variety of object
types. As we’ll see, a set acts much like the keys of a valueless dictionary, but it supports
extra operations.
However, because sets are unordered and do not map keys to values, they are neither
sequence nor mapping types; they are a type category unto themselves. Moreover, be-
cause sets are fundamentally mathematical in nature (and for many readers, may seem
more academic and be used much less often than more pervasive objects like diction-
aries), we’ll explore the basic utility of Python’s set objects here.
Set basics in Python 2.6 and earlier
There are a few ways to make sets today, depending on which Python you use. Since
this book covers all, let’s begin with the case for 2.6 and earlier, which also is available
(and sometimes still required) in later Pythons; we’ll refine this for 2.7 and 3.X exten-
sions in a moment. To make a set object, pass in a sequence or other iterable object to
the built-in set function:
>>> x = set('abcde')
>>> y = set('bdxyz')
You get back a set object, which contains all the items in the object passed in (notice
that sets do not have a positional ordering, and so are not sequences—their order is
arbitrary and may vary per Python release):
>>> x
set(['a', 'c', 'b', 'e', 'd']) # Pythons <= 2.6 display format
Sets made this way support the common mathematical set operations with expres-
sion operators. Note that we can’t perform the following operations on plain sequences
like strings, lists, and tuples—we must create sets from them by passing them to set in
order to apply these tools:
>>> x − y # Difference
set(['a', 'c', 'e'])
>>> x | y # Union
set(['a', 'c', 'b', 'e', 'd', 'y', 'x', 'z'])
>>> x & y # Intersection
set(['b', 'd'])
>>> x ^ y # Symmetric difference (XOR)
set(['a', 'c', 'e', 'y', 'x', 'z'])
>>> x > y, x < y # Superset, subset
(False, False)
The notable exception to this rule is the in set membership test—this expression is also
defined to work on all other collection types, where it also performs membership (or a
164 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-216-320.jpg)
![search, if you prefer to think in procedural terms). Hence, we do not need to convert
things like strings and lists to sets to run this test:
>>> 'e' in x # Membership (sets)
True
>>> 'e' in 'Camelot', 22 in [11, 22, 33] # But works on other types too
(True, True)
In addition to expressions, the set object provides methods that correspond to these
operations and more, and that support set changes—the set add method inserts one
item, update is an in-place union, and remove deletes an item by value (run a dir call on
any set instance or the set type name to see all the available methods). Assuming x and
y are still as they were in the prior interaction:
>>> z = x.intersection(y) # Same as x & y
>>> z
set(['b', 'd'])
>>> z.add('SPAM') # Insert one item
>>> z
set(['b', 'd', 'SPAM'])
>>> z.update(set(['X', 'Y'])) # Merge: in-place union
>>> z
set(['Y', 'X', 'b', 'd', 'SPAM'])
>>> z.remove('b') # Delete one item
>>> z
set(['Y', 'X', 'd', 'SPAM'])
As iterable containers, sets can also be used in operations such as len, for loops, and
list comprehensions. Because they are unordered, though, they don’t support sequence
operations like indexing and slicing:
>>> for item in set('abc'): print(item * 3)
aaa
ccc
bbb
Finally, although the set expressions shown earlier generally require two sets, their
method-based counterparts can often work with any iterable type as well:
>>> S = set([1, 2, 3])
>>> S | set([3, 4]) # Expressions require both to be sets
set([1, 2, 3, 4])
>>> S | [3, 4]
TypeError: unsupported operand type(s) for |: 'set' and 'list'
>>> S.union([3, 4]) # But their methods allow any iterable
set([1, 2, 3, 4])
>>> S.intersection((1, 3, 5))
set([1, 3])
>>> S.issubset(range(-5, 5))
True
Other Numeric Types | 165](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-217-320.jpg)
![For more details on set operations, see Python’s library reference manual or a reference
book. Although set operations can be coded manually in Python with other types, like
lists and dictionaries (and often were in the past), Python’s built-in sets use efficient
algorithms and implementation techniques to provide quick and standard operation.
Set literals in Python 3.X and 2.7
If you think sets are “cool,” they eventually became noticeably cooler, with new syntax
for set literals and comprehensions initially added in the Python 3.X line only, but back-
ported to Python 2.7 by popular demand. In these Pythons we can still use the set built-
in to make set objects, but also a new set literal form, using the curly braces formerly
reserved for dictionaries. In 3.X and 2.7, the following are equivalent:
set([1, 2, 3, 4]) # Built-in call (all)
{1, 2, 3, 4} # Newer set literals (2.7, 3.X)
This syntax makes sense, given that sets are essentially like valueless dictionaries—
because a set’s items are unordered, unique, and immutable, the items behave much
like a dictionary’s keys. This operational similarity is even more striking given that
dictionary key lists in 3.X are view objects, which support set-like behavior such as
intersections and unions (see Chapter 8 for more on dictionary view objects).
Regardless of how a set is made, 3.X displays it using the new literal format. Python
2.7 accepts the new literal syntax, but still displays sets using the 2.6 display form of
the prior section. In all Pythons, the set built-in is still required to create empty sets
and to build sets from existing iterable objects (short of using set comprehensions,
discussed later in this chapter), but the new literal is convenient for initializing sets of
known structure.
Here’s what sets look like in 3.X; it’s the same in 2.7, except that set results display
with 2.X’s set([...]) notation, and item order may vary per version (which by defini-
tion is irrelevant in sets anyhow):
C:code> c:python33python
>>> set([1, 2, 3, 4]) # Built-in: same as in 2.6
{1, 2, 3, 4}
>>> set('spam') # Add all items in an iterable
{'s', 'a', 'p', 'm'}
>>> {1, 2, 3, 4} # Set literals: new in 3.X (and 2.7)
{1, 2, 3, 4}
>>> S = {'s', 'p', 'a', 'm'}
>>> S
{'s', 'a', 'p', 'm'}
>>> S.add('alot') # Methods work as before
>>> S
{'s', 'a', 'p', 'alot', 'm'}
All the set processing operations discussed in the prior section work the same in 3.X,
but the result sets print differently:
166 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-218-320.jpg)
![>>> S1 = {1, 2, 3, 4}
>>> S1 & {1, 3} # Intersection
{1, 3}
>>> {1, 5, 3, 6} | S1 # Union
{1, 2, 3, 4, 5, 6}
>>> S1 - {1, 3, 4} # Difference
{2}
>>> S1 > {1, 3} # Superset
True
Note that {} is still a dictionary in all Pythons. Empty sets must be created with the
set built-in, and print the same way:
>>> S1 - {1, 2, 3, 4} # Empty sets print differently
set()
>>> type({}) # Because {} is an empty dictionary
<class 'dict'>
>>> S = set() # Initialize an empty set
>>> S.add(1.23)
>>> S
{1.23}
As in Python 2.6 and earlier, sets created with 3.X/2.7 literals support the same meth-
ods, some of which allow general iterable operands that expressions do not:
>>> {1, 2, 3} | {3, 4}
{1, 2, 3, 4}
>>> {1, 2, 3} | [3, 4]
TypeError: unsupported operand type(s) for |: 'set' and 'list'
>>> {1, 2, 3}.union([3, 4])
{1, 2, 3, 4}
>>> {1, 2, 3}.union({3, 4})
{1, 2, 3, 4}
>>> {1, 2, 3}.union(set([3, 4]))
{1, 2, 3, 4}
>>> {1, 2, 3}.intersection((1, 3, 5))
{1, 3}
>>> {1, 2, 3}.issubset(range(-5, 5))
True
Immutable constraints and frozen sets
Sets are powerful and flexible objects, but they do have one constraint in both 3.X and
2.X that you should keep in mind—largely because of their implementation, sets can
only contain immutable (a.k.a. “hashable”) object types. Hence, lists and dictionaries
cannot be embedded in sets, but tuples can if you need to store compound values.
Tuples compare by their full values when used in set operations:
>>> S
{1.23}
>>> S.add([1, 2, 3]) # Only immutable objects work in a set
TypeError: unhashable type: 'list'
Other Numeric Types | 167](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-219-320.jpg)
![>>> S.add({'a':1})
TypeError: unhashable type: 'dict'
>>> S.add((1, 2, 3))
>>> S # No list or dict, but tuple OK
{1.23, (1, 2, 3)}
>>> S | {(4, 5, 6), (1, 2, 3)} # Union: same as S.union(...)
{1.23, (4, 5, 6), (1, 2, 3)}
>>> (1, 2, 3) in S # Membership: by complete values
True
>>> (1, 4, 3) in S
False
Tuples in a set, for instance, might be used to represent dates, records, IP addresses,
and so on (more on tuples later in this part of the book). Sets may also contain modules,
type objects, and more. Sets themselves are mutable too, and so cannot be nested in
other sets directly; if you need to store a set inside another set, the frozenset built-in
call works just like set but creates an immutable set that cannot change and thus can
be embedded in other sets.
Set comprehensions in Python 3.X and 2.7
In addition to literals, Python 3.X grew a set comprehension construct that was back-
ported for use to Python 2.7 too. Like the 3.X set literal, 2.7 accepts its syntax, but
displays its results in 2.X set notation. The set comprehension expression is similar in
form to the list comprehension we previewed in Chapter 4, but is coded in curly braces
instead of square brackets and run to make a set instead of a list. Set comprehensions
run a loop and collect the result of an expression on each iteration; a loop variable gives
access to the current iteration value for use in the collection expression. The result is a
new set you create by running the code, with all the normal set behavior. Here is a set
comprehension in 3.3 (again, result display and order differs in 2.7):
>>> {x ** 2 for x in [1, 2, 3, 4]} # 3.X/2.7 set comprehension
{16, 1, 4, 9}
In this expression, the loop is coded on the right, and the collection expression is coded
on the left (x ** 2). As for list comprehensions, we get back pretty much what this
expression says: “Give me a new set containing X squared, for every X in a list.” Com-
prehensions can also iterate across other kinds of objects, such as strings (the first of
the following examples illustrates the comprehension-based way to make a set from an
existing iterable):
>>> {x for x in 'spam'} # Same as: set('spam')
{'m', 's', 'p', 'a'}
>>> {c * 4 for c in 'spam'} # Set of collected expression results
{'pppp', 'aaaa', 'ssss', 'mmmm'}
>>> {c * 4 for c in 'spamham'}
{'pppp', 'aaaa', 'hhhh', 'ssss', 'mmmm'}
>>> S = {c * 4 for c in 'spam'}
168 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-220-320.jpg)
![>>> S | {'mmmm', 'xxxx'}
{'pppp', 'xxxx', 'mmmm', 'aaaa', 'ssss'}
>>> S & {'mmmm', 'xxxx'}
{'mmmm'}
Because the rest of the comprehensions story relies upon underlying concepts we’re
not yet prepared to address, we’ll postpone further details until later in this book. In
Chapter 8, we’ll meet a first cousin in 3.X and 2.7, the dictionary comprehension, and
I’ll have much more to say about all comprehensions—list, set, dictionary, and gener-
ator—later on, especially in Chapter 14 and Chapter 20. As we’ll learn there, all com-
prehensions support additional syntax not shown here, including nested loops and
if tests, which can be challenging to understand until you’ve had a chance to study
larger statements.
Why sets?
Set operations have a variety of common uses, some more practical than mathematical.
For example, because items are stored only once in a set, sets can be used to filter
duplicates out of other collections, though items may be reordered in the process be-
cause sets are unordered in general. Simply convert the collection to a set, and then
convert it back again (sets work in the list call here because they are iterable, another
technical artifact that we’ll unearth later):
>>> L = [1, 2, 1, 3, 2, 4, 5]
>>> set(L)
{1, 2, 3, 4, 5}
>>> L = list(set(L)) # Remove duplicates
>>> L
[1, 2, 3, 4, 5]
>>> list(set(['yy', 'cc', 'aa', 'xx', 'dd', 'aa'])) # But order may change
['cc', 'xx', 'yy', 'dd', 'aa']
Sets can be used to isolate differences in lists, strings, and other iterable objects too—
simply convert to sets and take the difference—though again the unordered nature of
sets means that the results may not match that of the originals. The last two of the
following compare attribute lists of string object types in 3.X (results vary in 2.7):
>>> set([1, 3, 5, 7]) - set([1, 2, 4, 5, 6]) # Find list differences
{3, 7}
>>> set('abcdefg') - set('abdghij') # Find string differences
{'c', 'e', 'f'}
>>> set('spam') - set(['h', 'a', 'm']) # Find differences, mixed
{'p', 's'}
>>> set(dir(bytes)) - set(dir(bytearray)) # In bytes but not bytearray
{'__getnewargs__'}
>>> set(dir(bytearray)) - set(dir(bytes))
{'append', 'copy', '__alloc__', '__imul__', 'remove', 'pop', 'insert', ...more...]
You can also use sets to perform order-neutral equality tests by converting to a set before
the test, because order doesn’t matter in a set. More formally, two sets are equal if and
Other Numeric Types | 169](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-221-320.jpg)
![only if every element of each set is contained in the other—that is, each is a subset of
the other, regardless of order. For instance, you might use this to compare the outputs
of programs that should work the same but may generate results in different order.
Sortingbeforetestinghas the sameeffectforequality, but setsdon’trelyonanexpensive
sort, and sorts order their results to support additional magnitude tests that sets do not
(greater, less, and so on):
>>> L1, L2 = [1, 3, 5, 2, 4], [2, 5, 3, 4, 1]
>>> L1 == L2 # Order matters in sequences
False
>>> set(L1) == set(L2) # Order-neutral equality
True
>>> sorted(L1) == sorted(L2) # Similar but results ordered
True
>>> 'spam' == 'asmp', set('spam') == set('asmp'), sorted('spam') == sorted('asmp')
(False, True, True)
Sets can also be used to keep track of where you’ve already been when traversing a
graph or other cyclic structure. For example, the transitive module reloader and inher-
itance tree lister examples we’ll study in Chapter 25 and Chapter 31, respectively, must
keep track of items visited to avoid loops, as Chapter 19 discusses in the abstract. Using
a list in this context is inefficient because searches require linear scans. Although re-
cording states visited as keys in a dictionary is efficient, sets offer an alternative that’s
essentially equivalent (and may be more or less intuitive, depending on whom you ask).
Finally, sets are also convenient when you’re dealing with large data sets (database
query results, for example)—the intersection of two sets contains objects common to
both categories, and the union contains all items in either set. To illustrate, here’s a
somewhat more realistic example of set operations at work, applied to lists of people
in a hypothetical company, using 3.X/2.7 set literals and 3.X result displays (use set in
2.6 and earlier):
>>> engineers = {'bob', 'sue', 'ann', 'vic'}
>>> managers = {'tom', 'sue'}
>>> 'bob' in engineers # Is bob an engineer?
True
>>> engineers & managers # Who is both engineer and manager?
{'sue'}
>>> engineers | managers # All people in either category
{'bob', 'tom', 'sue', 'vic', 'ann'}
>>> engineers - managers # Engineers who are not managers
{'vic', 'ann', 'bob'}
>>> managers - engineers # Managers who are not engineers
{'tom'}
>>> engineers > managers # Are all managers engineers? (superset)
False
170 | Chapter 5: Numeric Types](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-222-320.jpg)
![To illustrate, consider the following example, which sets the name x to a different object
on each assignment:
>>> x = 42
>>> x = 'shrubbery' # Reclaim 42 now (unless referenced elsewhere)
>>> x = 3.1415 # Reclaim 'shrubbery' now
>>> x = [1, 2, 3] # Reclaim 3.1415 now
First, notice that x is set to a different type of object each time. Again, though this is
not really the case, the effect is as though the type of x is changing over time. Remember,
in Python types live with objects, not names. Because names are just generic references
to objects, this sort of code works naturally.
Second, notice that references to objects are discarded along the way. Each time x is
assigned to a new object, Python reclaims the prior object’s space. For instance, when
it is assigned the string 'shrubbery', the object 42 is immediately reclaimed (assuming
it is not referenced anywhere else)—that is, the object’s space is automatically thrown
back into the free space pool, to be reused for a future object.
Internally, Python accomplishes this feat by keeping a counter in every object that keeps
track of the number of references currently pointing to that object. As soon as (and
exactly when) this counter drops to zero, the object’s memory space is automatically
reclaimed. In the preceding listing, we’re assuming that each time x is assigned to a new
object, the prior object’s reference counter drops to zero, causing it to be reclaimed.
The most immediately tangible benefit of garbage collection is that it means you can
use objects liberally without ever needing to allocate or free up space in your script.
Python will clean up unused space for you as your program runs. In practice, this
eliminates a substantial amount of bookkeeping code required in lower-level languages
such as C and C++.
More on Python Garbage Collection
Technically speaking, Python’s garbage collection is based mainly upon reference coun-
ters, as described here; however, it also has a component that detects and reclaims
objects with cyclic references in time. This component can be disabled if you’re sure
that your code doesn’t create cycles, but it is enabled by default.
Circular references are a classic issue in reference count garbage collectors. Because
references are implemented as pointers, it’s possible for an object to reference itself, or
reference another object that does. For example, exercise 3 at the end of Part I and its
solution in Appendix D show how to create a cycle easily by embedding a reference to
a list within itself (e.g., L.append(L)). The same phenomenon can occur for assignments
to attributes of objects created from user-defined classes. Though relatively rare, be-
cause the reference counts for such objects never drop to zero, they must be treated
specially.
For more details on Python’s cycle detector, see the documentation for the gc module
in Python’s library manual. The best news here is that garbage-collection-based mem-
ory management is implemented for you in Python, by people highly skilled at the task.
The Case of the Missing Declaration Statements | 179](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-231-320.jpg)
![Though you must take it somewhat on faith at this point in the book, this distinction
can matter much in your programs. For objects that support such in-place changes,
you need to be more aware of shared references, since a change from one name may
impact others. Otherwise, your objects may seem to change for no apparent reason.
Given that all assignments are based on references (including function argument pass-
ing), it’s a pervasive potential.
To illustrate, let’s take another look at the list objects introduced in Chapter 4. Recall
that lists, which do support in-place assignments to positions, are simply collections
of other objects, coded in square brackets:
>>> L1 = [2, 3, 4]
>>> L2 = L1
L1 here is a list containing the objects 2, 3, and 4. Items inside a list are accessed by their
positions, so L1[0] refers to object 2, the first item in the list L1. Of course, lists are also
objects in their own right, just like integers and strings. After running the two prior
assignments, L1 and L2 reference the same shared object, just like a and b in the prior
example (see Figure 6-2). Now say that, as before, we extend this interaction to say the
following:
>>> L1 = 24
This assignment simply sets L1 to a different object; L2 still references the original list.
If we change this statement’s syntax slightly, however, it has a radically different effect:
>>> L1 = [2, 3, 4] # A mutable object
>>> L2 = L1 # Make a reference to the same object
>>> L1[0] = 24 # An in-place change
>>> L1 # L1 is different
[24, 3, 4]
>>> L2 # But so is L2!
[24, 3, 4]
Really, we haven’t changed L1 itself here; we’ve changed a component of the object that
L1 references. This sort of change overwrites part of the list object’s value in place.
Because the list object is shared by (referenced from) other variables, though, an in-
place change like this doesn’t affect only L1—that is, you must be aware that when you
make such changes, they can impact other parts of your program. In this example, the
effect shows up in L2 as well because it references the same object as L1. Again, we
haven’t actually changed L2, either, but its value will appear different because it refers
to an object that has been overwritten in place.
This behavior only occurs for mutable objects that support in-place changes, and is
usually what you want, but you should be aware of how it works, so that it’s expected.
It’s also just the default: if you don’t want such behavior, you can request that Python
copy objects instead of making references. There are a variety of ways to copy a list,
includingusingthebuilt-inlist functionandthestandardlibrarycopy module.Perhaps
182 | Chapter 6: The Dynamic Typing Interlude](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-234-320.jpg)
![the most common way is to slice from start to finish (see Chapter 4 and Chapter 7 for
more on slicing):
>>> L1 = [2, 3, 4]
>>> L2 = L1[:] # Make a copy of L1 (or list(L1), copy.copy(L1), etc.)
>>> L1[0] = 24
>>> L1
[24, 3, 4]
>>> L2 # L2 is not changed
[2, 3, 4]
Here, the change made through L1 is not reflected in L2 because L2 references a copy
of the object L1 references, not the original; that is, the two variables point to different
pieces of memory.
Note that this slicing technique won’t work on the other major mutable core types,
dictionaries and sets, because they are not sequences—to copy a dictionary or set,
instead use their X.copy() method call (lists have one as of Python 3.3 as well), or pass
the original object to their type names, dict and set. Also, note that the standard library
copy module has a call for copying any object type generically, as well as a call for
copying nested object structures—a dictionary with nested lists, for example:
import copy
X = copy.copy(Y) # Make top-level "shallow" copy of any object Y
X = copy.deepcopy(Y) # Make deep copy of any object Y: copy all nested parts
We’ll explore lists and dictionaries in more depth, and revisit the concept of shared
references and copies, in Chapter 8 and Chapter 9. For now, keep in mind that objects
that can be changed in place (that is, mutable objects) are always open to these kinds
of effects in any code they pass through. In Python, this includes lists, dictionaries, sets,
and some objects defined with class statements. If this is not the desired behavior, you
can simply copy your objects as needed.
Shared References and Equality
In the interest of full disclosure, I should point out that the garbage-collection behavior
described earlier in this chapter may be more conceptual than literal for certain types.
Consider these statements:
>>> x = 42
>>> x = 'shrubbery' # Reclaim 42 now?
BecausePythoncachesandreusessmallintegersandsmallstrings,asmentionedearlier,
the object 42 here is probably not literally reclaimed; instead, it will likely remain in a
system table to be reused the next time you generate a 42 in your code. Most kinds of
objects, though, are reclaimed immediately when they are no longer referenced; for
those that are not, the caching mechanism is irrelevant to your code.
For instance, because of Python’s reference model, there are two different ways to check
for equality in a Python program. Let’s create a shared reference to demonstrate:
Shared References | 183](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-235-320.jpg)
![>>> L = [1, 2, 3]
>>> M = L # M and L reference the same object
>>> L == M # Same values
True
>>> L is M # Same objects
True
The first technique here, the == operator, tests whether the two referenced objects have
the same values; this is the method almost always used for equality checks in Python.
The second method, the is operator, instead tests for object identity—it returns True
only if both names point to the exact same object, so it is a much stronger form of
equality testing and is rarely applied in most programs.
Really, is simply compares the pointers that implement references, and it serves as a
way to detect shared references in your code if needed. It returns False if the names
point to equivalent but different objects, as is the case when we run two different literal
expressions:
>>> L = [1, 2, 3]
>>> M = [1, 2, 3] # M and L reference different objects
>>> L == M # Same values
True
>>> L is M # Different objects
False
Now, watch what happens when we perform the same operations on small numbers:
>>> X = 42
>>> Y = 42 # Should be two different objects
>>> X == Y
True
>>> X is Y # Same object anyhow: caching at work!
True
In this interaction, X and Y should be == (same value), but not is (same object) because
we ran two different literal expressions (42). Because small integers and strings are
cached and reused, though, is tells us they reference the same single object.
In fact, if you really want to look under the hood, you can always ask Python how many
references there are to an object: the getrefcount function in the standard sys module
returns the object’s reference count. When I ask about the integer object 1 in the IDLE
GUI, for instance, it reports 647 reuses of this same object (most of which are in IDLE’s
system code, not mine, though this returns 173 outside IDLE so Python must be
hoarding 1s as well):
>>> import sys
>>> sys.getrefcount(1) # 647 pointers to this shared piece of memory
647
This object caching and reuse is irrelevant to your code (unless you run the is check!).
Because you cannot change immutable numbers or strings in place, it doesn’t matter
how many references there are to the same object—every reference will always see the
184 | Chapter 6: The Dynamic Typing Interlude](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-236-320.jpg)
![Chapter Summary
This chapter took a deeper look at Python’s dynamic typing model—that is, the way
that Python keeps track of object types for us automatically, rather than requiring us
to code declaration statements in our scripts. Along the way, we learned how variables
and objects are associated by references in Python; we also explored the idea of garbage
collection, learned how shared references to objects can affect multiple variables, and
saw how references impact the notion of equality in Python.
Because there is just one assignment model in Python, and because assignment pops
up everywhere in the language, it’s important that you have a handle on the model
before moving on. The following quiz should help you review some of this chapter’s
ideas. After that, we’ll resume our core object tour in the next chapter, with strings.
Test Your Knowledge: Quiz
1. Consider the following three statements. Do they change the value printed for A?
A = "spam"
B = A
B = "shrubbery"
2. Consider these three statements. Do they change the printed value of A?
A = ["spam"]
B = A
B[0] = "shrubbery"
3. How about these—is A changed now?
A = ["spam"]
B = A[:]
B[0] = "shrubbery"
Test Your Knowledge: Answers
1. No: A still prints as "spam". When B is assigned to the string "shrubbery", all that
happens is that the variable B is reset to point to the new string object. A and B
initially share (i.e., reference/point to) the same single string object "spam", but two
names are never linked together in Python. Thus, setting B to a different object has
no effect on A. The same would be true if the last statement here were B = B +
'shrubbery',bytheway—theconcatenationwouldmakeanewobjectforitsresult,
which would then be assigned to B only. We can never overwrite a string (or num-
ber, or tuple) in place, because strings are immutable.
2. Yes: A now prints as ["shrubbery"]. Technically, we haven’t really changed either
A or B; instead, we’ve changed part of the object they both reference (point to) by
overwriting that object in place through the variable B. Because A references the
same object as B, the update is reflected in A as well.
186 | Chapter 6: The Dynamic Typing Interlude](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-238-320.jpg)
![3. No: A still prints as ["spam"]. The in-place assignment through B has no effect this
time because the slice expression made a copy of the list object before it was as-
signed to B. After the second assignment statement, there are two different list
objects that have the same value (in Python, we say they are ==, but not is). The
third statement changes the value of the list object pointed to by B, but not that
pointed to by A.
Test Your Knowledge: Answers | 187](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-239-320.jpg)
![than arrays. Unlike in C, in Python, strings come with a powerful set of processing
tools. Also unlike languages such as C, Python has no distinct type for individual char-
acters; instead, you just use one-character strings.
Strictly speaking, Python strings are categorized as immutable sequences, meaning that
the characters they contain have a left-to-right positional order and that they cannot
be changed in place. In fact, strings are the first representative of the larger class of
objects called sequences that we will study here. Pay special attention to the sequence
operations introduced in this chapter, because they will work the same on other se-
quence types we’ll explore later, such as lists and tuples.
Table 7-1 previews common string literals and operations we will discuss in this chap-
ter. Empty strings are written as a pair of quotation marks (single or double) with
nothing in between, and there are a variety of ways to code strings. For processing,
strings support expression operations such as concatenation (combining strings), slic-
ing (extracting sections), indexing (fetching by offset), and so on. Besides expressions,
Python also provides a set of string methods that implement common string-specific
tasks, as well as modules for more advanced text-processing tasks such as pattern
matching. We’ll explore all of these later in the chapter.
Table 7-1. Common string literals and operations
Operation Interpretation
S = '' Empty string
S = "spam's" Double quotes, same as single
S = 'snptax00m' Escape sequences
S = """...multiline...""" Triple-quoted block strings
S = r'tempspam' Raw strings (no escapes)
B = b'spxc4m' Byte strings in 2.6, 2.7, and 3.X (Chapter 4, Chapter 37)
U = u'spu00c4m' Unicode strings in 2.X and 3.3+ (Chapter 4, Chapter 37)
S1 + S2
S * 3
Concatenate, repeat
S[i]
S[i:j]
len(S)
Index, slice, length
"a %s parrot" % kind String formatting expression
"a {0} parrot".format(kind) String formatting method in 2.6, 2.7, and 3.X
S.find('pa')
S.rstrip()
S.replace('pa', 'xx')
S.split(',')
String methods (see ahead for all 43): search,
remove whitespace,
replacement,
split on delimiter,
String Basics | 191](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-243-320.jpg)
![Operation Interpretation
S.isdigit()
S.lower()
S.endswith('spam')
'spam'.join(strlist)
S.encode('latin-1')
B.decode('utf8')
content test,
case conversion,
end test,
delimiter join,
Unicode encoding,
Unicode decoding, etc. (see Table 7-3)
for x in S: print(x)
'spam' in S
[c * 2 for c in S]
map(ord, S)
Iteration, membership
re.match('sp(.*)am', line) Pattern matching: library module
Beyond the core set of string tools in Table 7-1, Python also supports more advanced
pattern-based string processing with the standard library’s re (for “regular expression”)
module, introduced in Chapter 4 and Chapter 36, and even higher-level text processing
tools such as XML parsers (discussed briefly in Chapter 37). This book’s scope, though,
is focused on the fundamentals represented by Table 7-1.
To cover the basics, this chapter begins with an overview of string literal forms and
string expressions, then moves on to look at more advanced tools such as string meth-
ods and formatting. Python comes with many string tools, and we won’t look at them
all here; the complete story is chronicled in the Python library manual and reference
books. Our goal here is to explore enough commonly used tools to give you a repre-
sentative sample; methods we won’t see in action here, for example, are largely anal-
ogous to those we will.
String Literals
By and large, strings are fairly easy to use in Python. Perhaps the most complicated
thing about them is that there are so many ways to write them in your code:
• Single quotes: 'spa"m'
• Double quotes: "spa'm"
• Triple quotes: '''... spam ...''', """... spam ..."""
• Escape sequences: "stpna0m"
• Raw strings: r"C:newtest.spm"
• Bytes literals in 3.X and 2.6+ (see Chapter 4, Chapter 37): b'spx01am'
• Unicode literals in 2.X and 3.3+ (see Chapter 4, Chapter 37): u'eggsu0020spam'
192 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-244-320.jpg)
![Despite its role, even a raw string cannot end in a single backslash, be-
cause the backslash escapes the following quote character—you still
must escape the surrounding quote character to embed it in the string.
That is, r"..." is not a valid string literal—a raw string cannot end in
an odd number of backslashes. If you need to end a raw string with a
single backslash, you can use two and slice off the second (r'1nbtc
'[:-1]), tack one on manually (r'1nbtc' + ''), or skip the raw
string syntax and just double up the backslashes in a normal string ('1
nbtc'). All three of these forms create the same eight-character
string containing three backslashes.
Triple Quotes Code Multiline Block Strings
So far, you’ve seen single quotes, double quotes, escapes, and raw strings in action.
Python also has a triple-quoted string literal format, sometimes called a block string,
that is a syntactic convenience for coding multiline text data. This form begins with
three quotes (of either the single or double variety), is followed by any number of lines
of text, and is closed with the same triple-quote sequence that opened it. Single and
double quotes embedded in the string’s text may be, but do not have to be, escaped—
the string does not end until Python sees three unescaped quotes of the same kind used
to start the literal. For example (the “...” here is Python’s prompt for continuation lines
outside IDLE: don’t type it yourself):
>>> mantra = """Always look
... on the bright
... side of life."""
>>>
>>> mantra
'Always lookn on the brightnside of life.'
This string spans three lines. As we learned in Chapter 3, in some interfaces, the inter-
active prompt changes to ... on continuation lines like this, but IDLE simply drops
down one line; this book shows listings in both forms, so extrapolate as needed. Either
way, Python collects all the triple-quoted text into a single multiline string, with em-
bedded newline characters (n) at the places where your code has line breaks. Notice
that, as in the literal, the second line in the result has leading spaces, but the third does
not—what you type is truly what you get. To see the string with the newlines inter-
preted, print it instead of echoing:
>>> print(mantra)
Always look
on the bright
side of life.
In fact, triple-quoted strings will retain all the enclosed text, including any to the right
of your code that you might intend as comments. So don’t do this—put your comments
above or below the quoted text, or use the automatic concatenation of adjacent strings
mentioned earlier, with explicit newlines if desired, and surrounding parentheses to
198 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-250-320.jpg)
![Boolean result instead of the substring’s position (the following uses a 3.X print call
and may leave your cursor a bit indented; in 2.X say print c, instead):
>>> myjob = "hacker"
>>> for c in myjob: print(c, end=' ') # Step through items, print each (3.X form)
...
h a c k e r
>>> "k" in myjob # Found
True
>>> "z" in myjob # Not found
False
>>> 'spam' in 'abcspamdef' # Substring search, no position returned
True
The for loop assigns a variable to successive items in a sequence (here, a string) and
executes one or more statements for each item. In effect, the variable c becomes a cursor
stepping across the string’s characters here. We will discuss iteration tools like these
and others listed in Table 7-1 in more detail later in this book (especially in Chap-
ter 14 and Chapter 20).
Indexing and Slicing
Because strings are defined as ordered collections of characters, we can access their
components by position. In Python, characters in a string are fetched by indexing—
providing the numeric offset of the desired component in square brackets after the
string. You get back the one-character string at the specified position.
As in the C language, Python offsets start at 0 and end at one less than the length of the
string. Unlike C, however, Python also lets you fetch items from sequences such as
strings using negative offsets. Technically, a negative offset is added to the length of a
string to derive a positive offset. You can also think of negative offsets as counting
backward from the end. The following interaction demonstrates:
>>> S = 'spam'
>>> S[0], S[−2] # Indexing from front or end
('s', 'a')
>>> S[1:3], S[1:], S[:−1] # Slicing: extract a section
('pa', 'pam', 'spa')
The first line defines a four-character string and assigns it the name S. The next line
indexes it in two ways: S[0] fetches the item at offset 0 from the left—the one-character
string 's'; S[−2] gets the item at offset 2 back from the end—or equivalently, at offset
(4 + (−2)) from the front. In more graphic terms, offsets and slices map to cells as shown
in Figure 7-1.1
1. More mathematically minded readers (and students in my classes) sometimes detect a small asymmetry
here: the leftmost item is at offset 0, but the rightmost is at offset −1. Alas, there is no such thing as a
distinct −0 value in Python.
Strings in Action | 201](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-253-320.jpg)
![The last line in the preceding example demonstrates slicing, a generalized form of in-
dexing that returns an entire section, not a single item. Probably the best way to think
of slicing is that it is a type of parsing (analyzing structure), especially when applied to
strings—it allows us to extract an entire section (substring) in a single step. Slices can
be used to extract columns of data, chop off leading and trailing text, and more. In fact,
we’ll explore slicing in the context of text parsing later in this chapter.
The basics of slicing are straightforward. When you index a sequence object such as a
string on a pair of offsets separated by a colon, Python returns a new object containing
the contiguous section identified by the offset pair. The left offset is taken to be the
lower bound (inclusive), and the right is the upper bound (noninclusive). That is, Python
fetches all items from the lower bound up to but not including the upper bound, and
returns a new object containing the fetched items. If omitted, the left and right bounds
default to 0 and the length of the object you are slicing, respectively.
For instance, in the example we just saw, S[1:3] extracts the items at offsets 1 and 2:
it grabs the second and third items, and stops before the fourth item at offset 3. Next,
S[1:] gets all items beyond the first—the upper bound, which is not specified, defaults
to the length of the string. Finally, S[:−1] fetches all but the last item—the lower bound
defaults to 0, and −1 refers to the last item, noninclusive.
This may seem confusing at first glance, but indexing and slicing are simple and pow-
erful tools to use, once you get the knack. Remember, if you’re unsure about the effects
of a slice, try it out interactively. In the next chapter, you’ll see that it’s even possible
to change an entire section of another object in one step by assigning to a slice (though
not for immutables like strings). Here’s a summary of the details for reference:
Indexing (S[i]) fetches components at offsets:
• The first item is at offset 0.
• Negative indexes mean to count backward from the end or right.
• S[0] fetches the first item.
• S[−2] fetches the second item from the end (like S[len(S)−2]).
Figure 7-1. Offsets and slices: positive offsets start from the left end (offset 0 is the first item), and
negatives count back from the right end (offset −1 is the last item). Either kind of offset can be used
to give positions in indexing and slicing operations.
202 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-254-320.jpg)
![Slicing (S[i:j]) extracts contiguous sections of sequences:
• The upper bound is noninclusive.
• Slice boundaries default to 0 and the sequence length, if omitted.
• S[1:3] fetches items at offsets 1 up to but not including 3.
• S[1:] fetches items at offset 1 through the end (the sequence length).
• S[:3] fetches items at offset 0 up to but not including 3.
• S[:−1] fetches items at offset 0 up to but not including the last item.
• S[:] fetches items at offsets 0 through the end—making a top-level copy of S.
Extended slicing (S[i:j:k]) accepts a step (or stride) k, which defaults to +1:
• Allows for skipping items and reversing order—see the next section.
The second-to-last bullet item listed here turns out to be a very common technique: it
makes a full top-level copy of a sequence object—an object with the same value, but a
distinct piece of memory (you’ll find more on copies in Chapter 9). This isn’t very useful
forimmutableobjectslikestrings,butitcomesinhandyforobjectsthatmaybechanged
in place, such as lists.
In the next chapter, you’ll see that the syntax used to index by offset (square brackets)
is used to index dictionaries by key as well; the operations look the same but have
different interpretations.
Extended slicing: The third limit and slice objects
In Python 2.3 and later, slice expressions have support for an optional third index, used
as a step (sometimes called a stride). The step is added to the index of each item ex-
tracted. The full-blown form of a slice is now X[I:J:K], which means “extract all the
items in X, from offset I through J−1, by K.” The third limit, K, defaults to +1, which is
why normally all items in a slice are extracted from left to right. If you specify an explicit
value, however, you can use the third limit to skip items or to reverse their order.
For instance, X[1:10:2] will fetch every other item in X from offsets 1–9; that is, it will
collect the items at offsets 1, 3, 5, 7, and 9. As usual, the first and second limits default
to 0 and the length of the sequence, respectively, so X[::2] gets every other item from
the beginning to the end of the sequence:
>>> S = 'abcdefghijklmnop'
>>> S[1:10:2] # Skipping items
'bdfhj'
>>> S[::2]
'acegikmo'
You can also use a negative stride to collect items in the opposite order. For example,
the slicing expression "hello"[::−1] returns the new string "olleh"—the first two
bounds default to 0 and the length of the sequence, as before, and a stride of−1 indicates
that the slice should go from right to left instead of the usual left to right. The effect,
therefore, is to reverse the sequence:
Strings in Action | 203](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-255-320.jpg)
![>>> S = 'hello'
>>> S[::−1] # Reversing items
'olleh'
With a negative stride, the meanings of the first two bounds are essentially reversed.
That is, the slice S[5:1:−1] fetches the items from 2 to 5, in reverse order (the result
contains items from offsets 5, 4, 3, and 2):
>>> S = 'abcedfg'
>>> S[5:1:−1] # Bounds roles differ
'fdec'
Skipping and reversing like this are the most common use cases for three-limit slices,
but see Python’s standard library manual for more details (or run a few experiments
interactively). We’ll revisit three-limit slices again later in this book, in conjunction
with the for loop statement.
Later in the book, we’ll also learn that slicing is equivalent to indexing with a slice
object, a finding of importance to class writers seeking to support both operations:
>>> 'spam'[1:3] # Slicing syntax
'pa'
>>> 'spam'[slice(1, 3)] # Slice objects with index syntax + object
'pa'
>>> 'spam'[::-1]
'maps'
>>> 'spam'[slice(None, None, −1)]
'maps'
Why You Will Care: Slices
Throughout this book, I will include common use-case sidebars (such as this one) to
give you a peek at how some of the language features being introduced are typically
used in real programs. Because you won’t be able to make much sense of realistic use
cases until you’ve seen more of the Python picture, these sidebars necessarily contain
many references to topics not introduced yet; at most, you should consider them pre-
views of ways that you may find these abstract language concepts useful for common
programming tasks.
For instance, you’ll see later that the argument words listed on a system command line
used to launch a Python program are made available in the argv attribute of the built-
in sys module:
# File echo.py
import sys
print(sys.argv)
% python echo.py −a −b −c
['echo.py', '−a', '−b', '−c']
Usually, you’re only interested in inspecting the arguments that follow the program
name. This leads to a typical application of slices: a single slice expression can be used
to return all but the first item of a list. Here, sys.argv[1:] returns the desired list,
204 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-256-320.jpg)
![['−a', '−b', '−c']. You can then process this list without having to accommodate the
program name at the front.
Slices are also often used to clean up lines read from input files. If you know that a line
will have an end-of-line character at the end (a n newline marker), you can get rid of
it with a single expression such as line[:−1], which extracts all but the last character
in the line (the lower limit defaults to 0). In both cases, slices do the job of logic that
must be explicit in a lower-level language.
Havingsaidthat,callingtheline.rstrip methodisoftenpreferredforstrippingnewline
characters because this call leaves the line intact if it has no newline character at the
end—a common case for files created with some text-editing tools. Slicing works if
you’re sure the line is properly terminated.
String Conversion Tools
One of Python’s design mottos is that it refuses the temptation to guess. As a prime
example, you cannot add a number and a string together in Python, even if the string
looks like a number (i.e., is all digits):
# Python 3.X
>>> "42" + 1
TypeError: Can't convert 'int' object to str implicitly
# Python 2.X
>>> "42" + 1
TypeError: cannot concatenate 'str' and 'int' objects
This is by design: because + can mean both addition and concatenation, the choice of
conversion would be ambiguous. Instead, Python treats this as an error. In Python,
magic is generally omitted if it will make your life more complex.
What to do, then, if your script obtains a number as a text string from a file or user
interface? The trick is that you need to employ conversion tools before you can treat a
string like a number, or vice versa. For instance:
>>> int("42"), str(42) # Convert from/to string
(42, '42')
>>> repr(42) # Convert to as-code string
'42'
The int function converts a string to a number, and the str function converts a number
to its string representation (essentially, what it looks like when printed). The repr
function (and the older backquotes expression, removed in Python 3.X) also converts
an object to its string representation, but returns the object as a string of code that can
be rerun to recreate the object. For strings, the result has quotes around it if displayed
with a print statement, which differs in form between Python lines:
>>> print(str('spam'), repr('spam')) # 2.X: print str('spam'), repr('spam')
spam 'spam'
Strings in Action | 205](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-257-320.jpg)
![For ASCII text, this is the familiar 7-bit integer that fits in a single byte in memory, but
the range of code points for other kinds of Unicode text may be wider (more on char-
acter sets and Unicode in Chapter 37). You can use a loop to apply these functions to
all characters in a string if required. These tools can also be used to perform a sort of
string-based math. To advance to the next character, for example, convert and do the
math in integer:
>>> S = '5'
>>> S = chr(ord(S) + 1)
>>> S
'6'
>>> S = chr(ord(S) + 1)
>>> S
'7'
At least for single-character strings, this provides an alternative to using the built-in
int function to convert from string to integer (though this only makes sense in character
sets that order items as your code expects!):
>>> int('5')
5
>>> ord('5') - ord('0')
5
Such conversions can be used in conjunction with looping statements, introduced in
Chapter 4 and covered in depth in the next part of this book, to convert a string of
binarydigitstotheircorrespondingintegervalues.Eachtimethroughtheloop,multiply
the current value by 2 and add the next digit’s integer value:
>>> B = '1101' # Convert binary digits to integer with ord
>>> I = 0
>>> while B != '':
... I = I * 2 + (ord(B[0]) - ord('0'))
... B = B[1:]
...
>>> I
13
A left-shift operation (I << 1) would have the same effect as multiplying by 2 here.
We’ll leave this change as a suggested exercise, though, both because we haven’t stud-
ied loops in detail yet and because the int and bin built-ins we met in Chapter 5 handle
binary conversion tasks for us as of Python 2.6 and 3.0:
>>> int('1101', 2) # Convert binary to integer: built-in
13
>>> bin(13) # Convert integer to binary: built-in
'0b1101'
Given enough time, Python tends to automate most common tasks!
Strings in Action | 207](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-259-320.jpg)
![Changing Strings I
Remember the term “immutable sequence”? As we’ve seen, the immutable part means
that you cannot change a string in place—for instance, by assigning to an index:
>>> S = 'spam'
>>> S[0] = 'x' # Raises an error!
TypeError: 'str' object does not support item assignment
How to modify text information in Python, then? To change a string, you generally
need to build and assign a new string using tools such as concatenation and slicing,
and then, if desired, assign the result back to the string’s original name:
>>> S = S + 'SPAM!' # To change a string, make a new one
>>> S
'spamSPAM!'
>>> S = S[:4] + 'Burger' + S[−1]
>>> S
'spamBurger!'
The first example adds a substring at the end of S, by concatenation. Really, it makes
a new string and assigns it back to S, but you can think of this as “changing” the original
string. The second example replaces four characters with six by slicing, indexing, and
concatenating. As you’ll see in the next section, you can achieve similar effects with
string method calls like replace:
>>> S = 'splot'
>>> S = S.replace('pl', 'pamal')
>>> S
'spamalot'
Like every operation that yields a new string value, string methods generate new string
objects. If you want to retain those objects, you can assign them to variable names.
Generating a new string object for each string change is not as inefficient as it may
sound—remember, as discussed in the preceding chapter, Python automatically
garbage-collects (reclaims the space of) old unused string objects as you go, so newer
objects reuse the space held by prior values. Python is usually more efficient than you
might expect.
Finally, it’s also possible to build up new text values with string formatting expressions.
Both of the following substitute objects into a string, in a sense converting the objects
to strings and changing the original string according to a format specification:
>>> 'That is %d %s bird!' % (1, 'dead') # Format expression: all Pythons
That is 1 dead bird!
>>> 'That is {0} {1} bird!'.format(1, 'dead') # Format method in 2.6, 2.7, 3.X
'That is 1 dead bird!'
Despite the substitution metaphor, though, the result of formatting is a new string
object, not a modified one. We’ll study formatting later in this chapter; as we’ll find,
formatting turns out to be more general and useful than this example implies. Because
208 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-260-320.jpg)
![is evaluated from left to right—Python will first fetch the method of the object and then
call it, passing in both object and the arguments. Or, in plain words, the method call
expression means this:
Call method to process object with arguments.
If the method computes a result, it will also come back as the result of the entire method-
call expression. As a more tangible example:
>>> S = 'spam'
>>> result = S.find('pa') # Call the find method to look for 'pa' in string S
This mapping holds true for methods of both built-in types, as well as user-defined
classes we’ll study later. As you’ll see throughout this part of the book, most objects
have callable methods, and all are accessed using this same method-call syntax. To call
an object method, as you’ll see in the following sections, you have to go through an
existing object; methods cannot be run (and make little sense) without a subject.
Methods of Strings
Table 7-3 summarizes the methods and call patterns for built-in string objects in Python
3.3; these change frequently, so be sure to check Python’s standard library manual for
the most up-to-date list, or run a dir or help call on any string (or the str type name)
interactively. Python 2.X’s string methods vary slightly; it includes a decode, for exam-
ple, because of its different handling of Unicode data (something we’ll discuss in
Chapter 37). In this table, S is a string object, and optional arguments are enclosed in
square brackets. String methods in this table implement higher-level operations such
as splitting and joining, case conversions, content tests, and substring searches and
replacements.
Table 7-3. String method calls in Python 3.3
S.capitalize() S.ljust(width [, fill])
S.casefold() S.lower()
S.center(width [, fill]) S.lstrip([chars])
S.count(sub [, start [, end]]) S.maketrans(x[, y[, z]])
S.encode([encoding [,errors]]) S.partition(sep)
S.endswith(suffix [, start [, end]]) S.replace(old, new [, count])
S.expandtabs([tabsize]) S.rfind(sub [,start [,end]])
S.find(sub [, start [, end]]) S.rindex(sub [, start [, end]])
S.format(fmtstr, *args, **kwargs) S.rjust(width [, fill])
S.index(sub [, start [, end]]) S.rpartition(sep)
S.isalnum() S.rsplit([sep[, maxsplit]])
S.isalpha() S.rstrip([chars])
S.isdecimal() S.split([sep [,maxsplit]])
210 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-262-320.jpg)
![S.isdigit() S.splitlines([keepends])
S.isidentifier() S.startswith(prefix [, start [, end]])
S.islower() S.strip([chars])
S.isnumeric() S.swapcase()
S.isprintable() S.title()
S.isspace() S.translate(map)
S.istitle() S.upper()
S.isupper() S.zfill(width)
S.join(iterable)
As you can see, there are quite a few string methods, and we don’t have space to cover
them all; see Python’s library manual or reference texts for all the fine points. To help
you get started, though, let’s work through some code that demonstrates some of the
most commonly used methods in action, and illustrates Python text-processing basics
along the way.
String Method Examples: Changing Strings II
As we’ve seen, because strings are immutable, they cannot be changed in place directly.
The bytearray supports in-place text changes in 2.6, 3.0, and later, but only for simple
8-bit types. We explored changes to text strings earlier, but let’s take a quick second
look here in the context of string methods.
In general, to make a new text value from an existing string, you construct a new string
with operations such as slicing and concatenation. For example, to replace two char-
acters in the middle of a string, you can use code like this:
>>> S = 'spammy'
>>> S = S[:3] + 'xx' + S[5:] # Slice sections from S
>>> S
'spaxxy'
But, if you’re really just out to replace a substring, you can use the stringreplace method
instead:
>>> S = 'spammy'
>>> S = S.replace('mm', 'xx') # Replace all mm with xx in S
>>> S
'spaxxy'
The replace method is more general than this code implies. It takes as arguments the
original substring (of any length) and the string (of any length) to replace it with, and
performs a global search and replace:
>>> 'aa$bb$cc$dd'.replace('$', 'SPAM')
'aaSPAMbbSPAMccSPAMdd'
String Methods | 211](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-263-320.jpg)
![In such a role, replace can be used as a tool to implement template replacements (e.g.,
in form letters). Notice that this time we simply printed the result, instead of assigning
it to a name—you need to assign results to names only if you want to retain them for
later use.
If you need to replace one fixed-size string that can occur at any offset, you can do a
replacement again, or search for the substring with the string find method and then
slice:
>>> S = 'xxxxSPAMxxxxSPAMxxxx'
>>> where = S.find('SPAM') # Search for position
>>> where # Occurs at offset 4
4
>>> S = S[:where] + 'EGGS' + S[(where+4):]
>>> S
'xxxxEGGSxxxxSPAMxxxx'
The find method returns the offset where the substring appears (by default, searching
fromthefront),or−1 ifitis notfound.Aswesaw earlier, it’sasubstringsearchoperation
just like the in expression, but find returns the position of a located substring.
Anotheroptionis tousereplace withathirdargumentto limitittoasinglesubstitution:
>>> S = 'xxxxSPAMxxxxSPAMxxxx'
>>> S.replace('SPAM', 'EGGS') # Replace all
'xxxxEGGSxxxxEGGSxxxx'
>>> S.replace('SPAM', 'EGGS', 1) # Replace one
'xxxxEGGSxxxxSPAMxxxx'
Notice that replace returns a new string object each time. Because strings are immut-
able, methods never really change the subject strings in place, even if they are called
“replace”!
The fact that concatenation operations and the replace method generate new string
objects each time they are run is actually a potential downside of using them to change
strings. If you have to apply many changes to a very large string, you might be able to
improve your script’s performance by converting the string to an object that does sup-
port in-place changes:
>>> S = 'spammy'
>>> L = list(S)
>>> L
['s', 'p', 'a', 'm', 'm', 'y']
The built-in list function (an object construction call) builds a new list out of the items
in any sequence—in this case, “exploding” the characters of a string into a list. Once
the string is in this form, you can make multiple changes to it without generating a new
copy for each change:
>>> L[3] = 'x' # Works for lists, not strings
>>> L[4] = 'x'
212 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-264-320.jpg)
![>>> L
['s', 'p', 'a', 'x', 'x', 'y']
If, after your changes, you need to convert back to a string (e.g., to write to a file), use
the string join method to “implode” the list back into a string:
>>> S = ''.join(L)
>>> S
'spaxxy'
The join method may look a bit backward at first sight. Because it is a method of strings
(not of lists), it is called through the desired delimiter. join puts the strings in a list (or
other iterable) together, with the delimiter between list items; in this case, it uses an
empty string delimiter to convert from a list back to a string. More generally, any string
delimiter and iterable of strings will do:
>>> 'SPAM'.join(['eggs', 'sausage', 'ham', 'toast'])
'eggsSPAMsausageSPAMhamSPAMtoast'
In fact, joining substrings all at once might often run faster than concatenating them
individually. Be sure to also see the earlier note about the mutable bytearray string
available as of Python 3.0 and 2.6, described fully in Chapter 37; because it may be
changed in place, it offers an alternative to this list/join combination for some kinds
of 8-bit text that must be changed often.
String Method Examples: Parsing Text
Another common role for string methods is as a simple form of text parsing—that is,
analyzing structure and extracting substrings. To extract substrings at fixed offsets, we
can employ slicing techniques:
>>> line = 'aaa bbb ccc'
>>> col1 = line[0:3]
>>> col3 = line[8:]
>>> col1
'aaa'
>>> col3
'ccc'
Here, the columns of data appear at fixed offsets and so may be sliced out of the original
string. This technique passes for parsing, as long as the components of your data have
fixed positions. If instead some sort of delimiter separates the data, you can pull out its
components by splitting. This will work even if the data may show up at arbitrary
positions within the string:
>>> line = 'aaa bbb ccc'
>>> cols = line.split()
>>> cols
['aaa', 'bbb', 'ccc']
The string split method chops up a string into a list of substrings, around a delimiter
string. We didn’t pass a delimiter in the prior example, so it defaults to whitespace—
String Methods | 213](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-265-320.jpg)
![the string is split at groups of one or more spaces, tabs, and newlines, and we get back
a list of the resulting substrings. In other applications, more tangible delimiters may
separate the data. This example splits (and hence parses) the string at commas, a sep-
arator common in data returned by some database tools:
>>> line = 'bob,hacker,40'
>>> line.split(',')
['bob', 'hacker', '40']
Delimiters can be longer than a single character, too:
>>> line = "i'mSPAMaSPAMlumberjack"
>>> line.split("SPAM")
["i'm", 'a', 'lumberjack']
Although there are limits to the parsing potential of slicing and splitting, both run very
fast and can handle basic text-extraction chores. Comma-separated text data is part of
the CSV file format; for more advanced tools on this front, see also the csv module in
Python’s standard library.
Other Common String Methods in Action
Other string methods have more focused roles—for example, to strip off whitespace
attheendofalineoftext,performcaseconversions,testcontent,andtestforasubstring
at the end or front:
>>> line = "The knights who say Ni!n"
>>> line.rstrip()
'The knights who say Ni!'
>>> line.upper()
'THE KNIGHTS WHO SAY NI!n'
>>> line.isalpha()
False
>>> line.endswith('Ni!n')
True
>>> line.startswith('The')
True
Alternative techniques can also sometimes be used to achieve the same results as string
methods—the in membership operator can be used to test for the presence of a sub-
string, for instance, and length and slicing operations can be used to mimic endswith:
>>> line
'The knights who say Ni!n'
>>> line.find('Ni') != −1 # Search via method call or expression
True
>>> 'Ni' in line
True
>>> sub = 'Ni!n'
>>> line.endswith(sub) # End test via method call or slice
True
214 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-266-320.jpg)
![>>> line[-len(sub):] == sub
True
See also the format string formatting method described later in this chapter; it provides
more advanced substitution tools that combine many operations in a single step.
Again, because there are so many methods available for strings, we won’t look at every
one here. You’ll see some additional string examples later in this book, but for more
details you can also turn to the Python library manual and other documentation sour-
ces, or simply experiment interactively on your own. You can also check the
help(S.method) results for a method of any string object S for more hints; as we saw in
Chapter 4, running help on str.method likely gives the same details.
Note that none of the string methods accepts patterns—for pattern-based text pro-
cessing, you must use the Python re standard library module, an advanced tool that
was introduced in Chapter 4 but is mostly outside the scope of this text (one further
brief example appears at the end of Chapter 37). Because of this limitation, though,
string methods may sometimes run more quickly than the re module’s tools.
The Original string Module’s Functions (Gone in 3.X)
The history of Python’s string methods is somewhat convoluted. For roughly the first
decade of its existence, Python provided a standard library module called string that
contained functions that largely mirrored the current set of string object methods. By
popular demand, in Python 2.0 these functions were made available as methods of
string objects. Because so many people had written so much code that relied on the
original string module, however, it was retained for backward compatibility.
Today, you should use only string methods, not the original string module. In fact, the
original module call forms of today’s string methods have been removed completely
from Python 3.X, and you should not use them in new code in either 2.X or 3.X. How-
ever, because you may still see the module in use in older Python 2.X code, and this
text covers both Pythons 2.X and 3.X, a brief look is in order here.
The upshot of this legacy is that in Python 2.X, there technically are still two ways to
invoke advanced string operations: by calling object methods, or by calling string
module functions and passing in the objects as arguments. For instance, given a variable
X assigned to a string object, calling an object method:
X.method(arguments)
is usually equivalent to calling the same operation through thestring module (provided
that you have already imported the module):
string.method(X, arguments)
Here’s an example of the method scheme in action:
>>> S = 'a+b+c+'
>>> x = S.replace('+', 'spam')
String Methods | 215](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-267-320.jpg)
![2. On the right of the % operator, provide the object (or objects, embedded in a tuple)
that you want Python to insert into the format string on the left in place of the
conversion target (or targets).
For instance, in the formatting example we saw earlier in this chapter, the integer 1
replaces the %d in the format string on the left, and the string 'dead' replaces the %s.
The result is a new string that reflects these two substitutions, which may be printed
or saved for use in other roles:
>>> 'That is %d %s bird!' % (1, 'dead') # Format expression
That is 1 dead bird!
Technically speaking, string formatting expressions are usually optional—you can
generally do similar work with multiple concatenations and conversions. However,
formatting allows us to combine many steps into a single operation. It’s powerful
enough to warrant a few more examples:
>>> exclamation = 'Ni'
>>> 'The knights who say %s!' % exclamation # String substitution
'The knights who say Ni!'
>>> '%d %s %g you' % (1, 'spam', 4.0) # Type-specific substitutions
'1 spam 4 you'
>>> '%s -- %s -- %s' % (42, 3.14159, [1, 2, 3]) # All types match a %s target
'42 -- 3.14159 -- [1, 2, 3]'
The first example here plugs the string 'Ni' into the target on the left, replacing the
%s marker. In the second example, three values are inserted into the target string. Note
that when you’re inserting more than one value, you need to group the values on the
right in parentheses (i.e., put them in a tuple). The % formatting expression operator
expects either a single item or a tuple of one or more items on its right side.
The third example again inserts three values—an integer, a floating-point object, and
a list object—but notice that all of the targets on the left are %s, which stands for con-
version to string. As every type of object can be converted to a string (the one used
when printing), every object type works with the %s conversion code. Because of this,
unless you will be doing some special formatting, %s is often the only code you need to
remember for the formatting expression.
Again, keep in mind that formatting always makes a new string, rather than changing
the string on the left; because strings are immutable, it must work this way. As before,
assign the result to a variable name if you need to retain it.
Advanced Formatting Expression Syntax
For more advanced type-specific formatting, you can use any of the conversion type
codes listed in Table 7-4 in formatting expressions; they appear after the % character in
substitution targets. C programmers will recognize most of these because Python string
formatting supports all the usual C printf format codes (but returns the result, instead
218 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-270-320.jpg)
![of displaying it, like printf). Some of the format codes in the table provide alternative
ways to format the same type; for instance, %e, %f, and %g provide alternative ways to
format floating-point numbers.
Table 7-4. String formatting type codes
Code Meaning
s String (or any object’s str(X) string)
r Same as s, but uses repr, not str
c Character (int or str)
d Decimal (base-10 integer)
i Integer
u Same as d (obsolete: no longer unsigned)
o Octal integer (base 8)
x Hex integer (base 16)
X Same as x, but with uppercase letters
e Floating point with exponent, lowercase
E Same as e, but uses uppercase letters
f Floating-point decimal
F Same as f, but uses uppercase letters
g Floating-point e or f
G Floating-point E or F
% Literal % (coded as %%)
In fact, conversion targets in the format string on the expression’s left side support a
variety of conversion operations with a fairly sophisticated syntax all their own. The
general structure of conversion targets looks like this:
%[(keyname)][flags][width][.precision]typecode
The type code characters in the first column of Table 7-4 show up at the end of this
target string’s format. Between the % and the type code character, you can do any of the
following:
• Provide a key name for indexing the dictionary used on the right side of the ex-
pression
• Listflagsthatspecifythingslikeleftjustification(−),numericsign(+),ablankbefore
positive numbers and a – for negatives (a space), and zero fills (0)
• Give a total minimum field width for the substituted text
• Set the number of digits (precision) to display after a decimal point for floating-
point numbers
String Formatting Expressions | 219](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-271-320.jpg)
![By comparison, the last section’s formatting expression can be a bit more concise, but
uses dictionaries instead of keyword arguments, and doesn’t allow quite as much flex-
ibility for value sources (which may be an asset or liability, depending on your per-
spective); more on how the two techniques compare ahead:
>>> template = '%s, %s and %s' # Same via expression
>>> template % ('spam', 'ham', 'eggs')
'spam, ham and eggs'
>>> template = '%(motto)s, %(pork)s and %(food)s'
>>> template % dict(motto='spam', pork='ham', food='eggs')
'spam, ham and eggs'
Note the use of dict() to make a dictionary from keyword arguments here, introduced
in Chapter 4 and covered in full in Chapter 8; it’s an often less-cluttered alternative to
the {...} literal. Naturally, the subject string in the format method call can also be a
literal that creates a temporary string, and arbitrary object types can be substituted at
targets much like the expression’s %s code:
>>> '{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2])
'3.14, 42 and [1, 2]'
Just as with the % expression and other string methods, format creates and returns a
new string object, which can be printed immediately or saved for further work (recall
that strings are immutable, so format really must make a new object). String formatting
is not just for display:
>>> X = '{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2])
>>> X
'3.14, 42 and [1, 2]'
>>> X.split(' and ')
['3.14, 42', '[1, 2]']
>>> Y = X.replace('and', 'but under no circumstances')
>>> Y
'3.14, 42 but under no circumstances [1, 2]'
Adding Keys, Attributes, and Offsets
Like % formatting expressions, format calls can become more complex to support more
advanced usage. For instance, format strings can name object attributes and dictionary
keys—as in normal Python syntax, square brackets name dictionary keys and dots
denote object attributes of an item referenced by position or keyword. The first of the
following examples indexes a dictionary on the key “spam” and then fetches the at-
tribute “platform” from the already imported sys module object. The second does the
same, but names the objects by keyword instead of position:
>>> import sys
>>> 'My {1[kind]} runs {0.platform}'.format(sys, {'kind': 'laptop'})
'My laptop runs win32'
String Formatting Method Calls | 223](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-275-320.jpg)
![>>> 'My {map[kind]} runs {sys.platform}'.format(sys=sys, map={'kind': 'laptop'})
'My laptop runs win32'
Square brackets in format strings can name list (and other sequence) offsets to perform
indexing, too, but only single positive offsets work syntactically within format strings,
so this feature is not as general as you might think. As with % expressions, to name
negative offsets or slices, or to use arbitrary expression results in general, you must run
expressions outside the format string itself (note the use of *parts here to unpack a
tuple’s items into individual function arguments, as we did in Chapter 5 when studying
fractions; more on this form in Chapter 18):
>>> somelist = list('SPAM')
>>> somelist
['S', 'P', 'A', 'M']
>>> 'first={0[0]}, third={0[2]}'.format(somelist)
'first=S, third=A'
>>> 'first={0}, last={1}'.format(somelist[0], somelist[-1]) # [-1] fails in fmt
'first=S, last=M'
>>> parts = somelist[0], somelist[-1], somelist[1:3] # [1:3] fails in fmt
>>> 'first={0}, last={1}, middle={2}'.format(*parts) # Or '{}' in 2.7/3.1+
"first=S, last=M, middle=['P', 'A']"
Advanced Formatting Method Syntax
Another similarity with % expressions is that you can achieve more specific layouts by
adding extra syntax in the format string. For the formatting method, we use a colon
after the possibly empty substitution target’s identification, followed by a format speci-
fier that can name the field size, justification, and a specific type code. Here’s the formal
structure of what can appear as a substitution target in a format string—its four parts
are all optional, and must appear without intervening spaces:
{fieldname component !conversionflag :formatspec}
In this substitution target syntax:
• fieldname is an optional number or keyword identifying an argument, which may
be omitted to use relative argument numbering in 2.7, 3.1, and later.
• component is a string of zero or more “.name” or “[index]” references used to fetch
attributes and indexed values of the argument, which may be omitted to use the
whole argument value.
• conversionflag starts with a ! if present, which is followed by r, s, or a to call repr,
str, or ascii built-in functions on the value, respectively.
• formatspec starts with a : if present, which is followed by text that specifies how
the value should be presented, including details such as field width, alignment,
padding, decimal precision, and so on, and ends with an optional data type code.
224 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-276-320.jpg)
![The formatspec component after the colon character has a rich format all its own, and
is formally described as follows (brackets denote optional components and are not
coded literally):
[[fill]align][sign][#][0][width][,][.precision][typecode]
In this, fill can be any fill character other than { or }; align may be <, >, =, or ^, for
left alignment, right alignment, padding after a sign character, or centered alignment,
respectively; sign may be +, −, or space; and the , (comma) option requests a comma
for a thousands separator as of Python 2.7 and 3.1. width and precision are much as
in the % expression, and the formatspec may also contain nested {} format strings with
field names only, to take values from the arguments list dynamically (much like the *
in formatting expressions).
The method’s typecode options almost completely overlap with those used in % ex-
pressions and listed previously in Table 7-4, but the format method also allows a b type
code used to display integers in binary format (it’s equivalent to using the bin built-in
call), allows a % type code to display percentages, and uses only d for base-10 integers
(i or u are not used here). Note that unlike the expression’s %s, the s type code here
requires a string object argument; omit the type code to accept any type generically.
See Python’s library manual for more on substitution syntax that we’ll omit here. In
addition to the string’s format method, a single object may also be formatted with the
format(object, formatspec) built-in function (which the method uses internally), and
may be customized in user-defined classes with the __format__ operator-overloading
method (see Part VI).
Advanced Formatting Method Examples
As you can tell, the syntax can be complex in formatting methods. Because your best
ally in such cases is often the interactive prompt here, let’s turn to some examples. In
the following, {0:10} means the first positional argument in a field 10 characters wide,
{1:<10} means the second positional argument left-justified in a 10-character-wide
field, and {0.platform:>10} means the platform attribute of the first argument right-
justified in a 10-character-wide field (note again the use of dict() to make a dictionary
from keyword arguments, covered in Chapter 4 and Chapter 8):
>>> '{0:10} = {1:10}'.format('spam', 123.4567) # In Python 3.3
'spam = 123.4567'
>>> '{0:>10} = {1:<10}'.format('spam', 123.4567)
' spam = 123.4567 '
>>> '{0.platform:>10} = {1[kind]:<10}'.format(sys, dict(kind='laptop'))
' win32 = laptop '
In all cases, you can omit the argument number as of Python 2.7 and 3.1 if you’re
selecting them from left to right with relative autonumbering—though this makes your
String Formatting Method Calls | 225](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-277-320.jpg)
![code less explicit, thereby negating one of the reported advantages of the formatting
method over the formatting expression (see the related note ahead):
>>> '{:10} = {:10}'.format('spam', 123.4567)
'spam = 123.4567'
>>> '{:>10} = {:<10}'.format('spam', 123.4567)
' spam = 123.4567 '
>>> '{.platform:>10} = {[kind]:<10}'.format(sys, dict(kind='laptop'))
' win32 = laptop '
Floating-point numbers support the same type codes and formatting specificity in for-
matting method calls as in % expressions. For instance, in the following {2:g} means
the third argument formatted by default according to the “g” floating-point represen-
tation, {1:.2f} designates the “f” floating-point format with just two decimal digits,
and {2:06.2f} adds a field with a width of six characters and zero padding on the left:
>>> '{0:e}, {1:.3e}, {2:g}'.format(3.14159, 3.14159, 3.14159)
'3.141590e+00, 3.142e+00, 3.14159'
>>> '{0:f}, {1:.2f}, {2:06.2f}'.format(3.14159, 3.14159, 3.14159)
'3.141590, 3.14, 003.14'
Hex, octal, and binary formats are supported by the format method as well. In fact,
string formatting is an alternative to some of the built-in functions that format integers
to a given base:
>>> '{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # Hex, octal, binary
'FF, 377, 11111111'
>>> bin(255), int('11111111', 2), 0b11111111 # Other to/from binary
('0b11111111', 255, 255)
>>> hex(255), int('FF', 16), 0xFF # Other to/from hex
('0xff', 255, 255)
>>> oct(255), int('377', 8), 0o377 # Other to/from octal, in 3.X
('0o377', 255, 255) # 2.X prints and accepts 0377
Formatting parameters can either be hardcoded in format strings or taken from the
arguments list dynamically by nested format syntax, much like the * syntax in format-
ting expressions’ width and precision:
>>> '{0:.2f}'.format(1 / 3.0) # Parameters hardcoded
'0.33'
>>> '%.2f' % (1 / 3.0) # Ditto for expression
'0.33'
>>> '{0:.{1}f}'.format(1 / 3.0, 4) # Take value from arguments
'0.3333'
>>> '%.*f' % (4, 1 / 3.0) # Ditto for expression
'0.3333'
226 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-278-320.jpg)
![Finally, Python 2.6 and 3.0 also introduced a new built-in format function, which can
be used to format a single item. It’s a more concise alternative to the string format
method, and is roughly similar to formatting a single item with the % formatting ex-
pression:
>>> '{0:.2f}'.format(1.2345) # String method
'1.23'
>>> format(1.2345, '.2f') # Built-in function
'1.23'
>>> '%.2f' % 1.2345 # Expression
'1.23'
Technically, the format built-in runs the subject object’s __format__ method, which the
str.format method does internally for each formatted item. It’s still more verbose than
the original % expression’s equivalent here, though—which leads us to the next section.
Comparison to the % Formatting Expression
If you study the prior sections closely, you’ll probably notice that at least for positional
references and dictionary keys, the string format method looks very much like the %
formatting expression, especially in advanced use with type codes and extra formatting
syntax. In fact, in common use cases formatting expressions may be easier to code than
formatting method calls, especially when you’re using the generic %s print-string sub-
stitution target, and even with autonumbering of fields added in 2.7 and 3.1:
print('%s=%s' % ('spam', 42)) # Format expression: in all 2.X/3.X
print('{0}={1}'.format('spam', 42)) # Format method: in 3.0+ and 2.6+
print('{}={}'.format('spam', 42)) # With autonumbering: in 3.1+ and 2.7
As we’ll see in a moment, more complex formatting tends to be a draw in terms of
complexity (difficult tasks are generally difficult, regardless of approach), and some see
the formatting method as redundant given the pervasiveness of the expression.
On the other hand, the formatting method also offers a few potential advantages. For
example, the original % expression can’t handle keywords, attribute references, and
binary type codes, although dictionary key references in % format strings can often
achieve similar goals. To see how the two techniques overlap, compare the following
% expressions to the equivalent format method calls shown earlier:
>>> '%s, %s and %s' % (3.14, 42, [1, 2]) # Arbitrary types
'3.14, 42 and [1, 2]'
>>> 'My %(kind)s runs %(platform)s' % {'kind': 'laptop', 'platform': sys.platform}
'My laptop runs win32'
>>> 'My %(kind)s runs %(platform)s' % dict(kind='laptop', platform=sys.platform)
'My laptop runs win32'
>>> somelist = list('SPAM')
String Formatting Method Calls | 227](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-279-320.jpg)
![>>> parts = somelist[0], somelist[-1], somelist[1:3]
>>> 'first=%s, last=%s, middle=%s' % parts
"first=S, last=M, middle=['P', 'A']"
When more complex formatting is applied the two techniques approach parity in terms
of complexity, although if you compare the following with the format method call
equivalents listed earlier you’ll again find that the % expressions tend to be a bit simpler
and more concise; in Python 3.3:
# Adding specific formatting
>>> '%-10s = %10s' % ('spam', 123.4567)
'spam = 123.4567'
>>> '%10s = %-10s' % ('spam', 123.4567)
' spam = 123.4567 '
>>> '%(plat)10s = %(kind)-10s' % dict(plat=sys.platform, kind='laptop')
' win32 = laptop '
# Floating-point numbers
>>> '%e, %.3e, %g' % (3.14159, 3.14159, 3.14159)
'3.141590e+00, 3.142e+00, 3.14159'
>>> '%f, %.2f, %06.2f' % (3.14159, 3.14159, 3.14159)
'3.141590, 3.14, 003.14'
# Hex and octal, but not binary (see ahead)
>>> '%x, %o' % (255, 255)
'ff, 377'
The format method has a handful of advanced features that the % expression does not,
but even more involved formatting still seems to be essentially a draw in terms of com-
plexity. For instance, the following shows the same result generated with both techni-
ques, with field sizes and justifications and various argument reference methods:
# Hardcoded references in both
>>> import sys
>>> 'My {1[kind]:<8} runs {0.platform:>8}'.format(sys, {'kind': 'laptop'})
'My laptop runs win32'
>>> 'My %(kind)-8s runs %(plat)8s' % dict(kind='laptop', plat=sys.platform)
'My laptop runs win32'
In practice, programs are less likely to hardcode references like this than to execute
code that builds up a set of substitution data ahead of time (for instance, to collect
input form or database data to substitute into an HTML template all at once). When
we account for common practice in examples like this, the comparison between the
format method and the % expression is even more direct:
228 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-280-320.jpg)
!['9,999,999 8,888,888'
>>> '%s' % money(296999.2567)
'$296,999.26'
Andasusual,asimplefunctionlikethiscanbeappliedinmoreadvanced
contexts too, such as the iteration tools we met in Chapter 4 and will
study fully in later chapters:
>>> [commas(x) for x in (9999999, 8888888)]
['9,999,999', '8,888,888']
>>> '%s %s' % tuple(commas(x) for x in (9999999, 8888888))
'9,999,999 8,888,888'
>>> ''.join(commas(x) for x in (9999999, 8888888))
'9,999,9998,888,888'
For better or worse, Python developers often seem to prefer adding spe-
cial-case built-in tools over general development techniques—a tradeoff
explored in the next section.
Why the Format Method?
Now that I’ve gone to such lengths to compare and contrast the two formatting tech-
niques, I wish to also explain why you still might want to consider using the format
method variant at times. In short, although the formatting method can sometimes re-
quire more code, it also:
• Has a handful of extra features not found in the % expression itself (though % can
use alternatives)
• Has more flexible value reference syntax (though it may be overkill, and % often
has equivalents)
• Can make substitution value references more explicit (though this is now optional)
• Trades an operator for a more mnemonic method name (though this is also more
verbose)
• Does not allow different syntax for single and multiple values (though practice
suggests this is trivial)
• As a function can be used in places an expression cannot (though a one-line func-
tion renders this moot)
Although both techniques are available today and the formatting expression is still
widely used, the format method might eventually grow in popularity and may receive
more attention from Python developers in the future. Further, with both the expression
and method in the language, either may appear in code you will encounter so it be-
hooves you to understand both. But because the choice is currently still yours to make
in new code, let’s briefly expand on the tradeoffs before closing the book on this topic.
Extra features: Special-case “batteries” versus general techniques
The method call supports a few extras that the expression does not, such as binary type
codes and (as of Python 2.7 and 3.1) thousands groupings. As we’ve seen, though, the
230 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-282-320.jpg)
![formatting expression can usually achieve the same effects in other ways. Here’s the
case for binary formatting:
>>> '{0:b}'.format((2 ** 16) − 1) # Expression (only) binary format code
'1111111111111111'
>>> '%b' % ((2 ** 16) − 1)
ValueError: unsupported format character 'b'...
>>> bin((2 ** 16) − 1) # But other more general options work too
'0b1111111111111111'
>>> '%s' % bin((2 ** 16) - 1) # Usable with both method and % expression
'0b1111111111111111'
>>> '{}'.format(bin((2 ** 16) - 1)) # With 2.7/3.1+ relative numbering
'0b1111111111111111'
>>> '%s' % bin((2 ** 16) - 1)[2:] # Slice off 0b to get exact equivalent
'1111111111111111'
The preceding note showed that general functions could similarly stand in for the for-
mat method’s thousands groupings option, and more fully support customization. In
thiscase,asimple8-linereusablefunctionbuysusthesameutilitywithoutextraspecial-
case syntax:
>>> '{:,d}'.format(999999999999) # New str.format method feature in 3.1/2.7
'999,999,999,999'
>>> '%s' % commas(999999999999) # But % is same with simple 8-line function
'999,999,999,999'
See the prior note for more comma comparisons. This is essentially the same as the
preceding bin case for binary formatting, but the commas function here is user-defined,
not built in. As such, this technique is far more general purpose than precoded tools or
special syntax added for a single purpose.
This case also seems indicative, perhaps, of a trend in Python (and scripting language
in general) toward relying more on special-case “batteries included” tools than on gen-
eral development techniques—a mindset that makes code dependent on those batter-
ies, and seems difficult to justify unless one views software development as an end-user
enterprise. To some, programmers might be better served learning how to code an
algorithm to insert commas than be provided a tool that does.
We’ll leave that philosophical debate aside here, but in practical terms the net effect of
the trend in this case is extra syntax for you to have to both learn and remember. Given
their alternatives, it’s not clear that these extra features of the methods by themselves
are compelling enough to be decisive.
Flexible reference syntax: Extra complexity and functional overlap
The method call also supports key and attribute references directly, which some may
see as more flexible. But as we saw in earlier examples comparing dictionary-based
formatting in the % expression to key and attribute references in the format method, the
String Formatting Method Calls | 231](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-283-320.jpg)
![two are usually too similar to warrant a preference on these grounds. For instance, both
can reference the same value multiple times:
>>> '{name} {job} {name}'.format(name='Bob', job='dev')
'Bob dev Bob'
>>> '%(name)s %(job)s %(name)s' % dict(name='Bob', job='dev')
'Bob dev Bob'
Especially in common practice, though, the expression seems just as simple, or simpler:
>>> D = dict(name='Bob', job='dev')
>>> '{0[name]} {0[job]} {0[name]}'.format(D) # Method, key references
'Bob dev Bob'
>>> '{name} {job} {name}'.format(**D) # Method, dict-to-args
'Bob dev Bob'
>>> '%(name)s %(job)s %(name)s' % D # Expression, key references
'Bob dev Bob'
To be fair, the method has even more specialized substitution syntax, and other com-
parisons might favor either scheme in small ways. But given the overlap and extra
complexity, one could argue that the format method’s utility seems either a wash, or
features in search of use cases. At the least, the added conceptual burden on Python
programmers who may now need to know both tools doesn’t seem clearly justified.
Explicit value references: Now optional and unlikely to be used
One use case where the format method is at least debatably clearer is when there are
many values to be substituted into the format string. The lister.py classes example we’ll
meet in Chapter 31, for example, substitutes six items into a single string, and in this
case the method’s {i} position labels seem marginally easier to read than the expres-
sion’s %s:
'n%s<Class %s, address %s:n%s%s%s>n' % (...) # Expression
'n{0}<Class {1}, address {2}:n{3}{4}{5}>n'.format(...) # Method
On the other hand, using dictionary keys in % expressions can mitigate much of this
difference. This is also something of a worst-case scenario for formatting complexity,
andnotverycommoninpractice;moretypicalusecasesseemmoreofatossup.Further,
as of Python 3.1 and 2.7, numbering substitution targets becomes optional when rel-
ative to position, potentially subverting this purported benefit altogether:
>>> 'The {0} side {1} {2}'.format('bright', 'of', 'life') # Python 3.X, 2.6+
'The bright side of life'
>>> 'The {} side {} {}'.format('bright', 'of', 'life') # Python 3.1+, 2.7+
'The bright side of life'
>>> 'The %s side %s %s' % ('bright', 'of', 'life') # All Pythons
'The bright side of life'
Given its conciseness, the second of these is likely to be preferred to the first, but seems
to negate part of the method’s advantage. Compare the effect on floating-point for-
232 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-284-320.jpg)
![quence object, including strings, lists, and tuples. The only difference is that when
you slice a list, you get back a new list.
3. The built-in ord(S) function converts from a one-character string to an integer
character code; chr(I) converts from the integer code back to a string. Keep in
mind, though, that these integers are only ASCII codes for text whose characters
are drawn only from ASCII character set. In the Unicode model, text strings are
really sequences of Unicode code point identifying integers, which may fall outside
the 7-bit range of numbers reserved by ASCII (more on Unicode in Chapter 4 and
Chapter 37).
4. Strings cannot be changed; they are immutable. However, you can achieve a similar
effect by creating a new string—by concatenating, slicing, running formatting ex-
pressions, or using a method call like replace—and then assigning the result back
to the original variable name.
5. You can slice the string using S[2:4], or split on the comma and index the string
using S.split(',')[1]. Try these interactively to see for yourself.
6. Six. The string "anbx1f000d" contains the characters a, newline (n), b, binary
31 (a hex escape x1f), binary 0 (an octal escape 000), and d. Pass the string to the
built-in len function to verify this, and print each of its character’s ord results to
seetheactualcodepoint(identifyingnumber)values.SeeTable7-2 formoredetails
on escapes.
7. You should never use the string module instead of string object method calls today
—it’s deprecated, and its calls are removed completely in Python 3.X. The only
valid reason for using the string module at all today is for its other tools, such as
predefined constants. You might also see it appear in what is now very old and
dusty Python code (and books of the misty past—like the 1990s).
238 | Chapter 7: String Fundamentals](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-290-320.jpg)
![ous). Because lists can contain other complex objects, they also support arbitrary
nesting; you can create lists of lists of lists, and so on.
Of the category “mutable sequence”
In terms of our type category qualifiers, lists are mutable (i.e., can be changed in
place) and can respond to all the sequence operations used with strings, such as
indexing, slicing, and concatenation. In fact, sequence operations work the same
on lists as they do on strings; the only difference is that sequence operations such
as concatenation and slicing return new lists instead of new strings when applied
to lists. Because lists are mutable, however, they also support other operations that
strings don’t, such as deletion and index assignment operations, which change the
lists in place.
Arrays of object references
Technically, Python lists contain zero or more references to other objects. Lists
might remind you of arrays of pointers (addresses) if you have a background in
some other languages. Fetching an item from a Python list is about as fast as in-
dexing a C array; in fact, lists really are arrays inside the standard Python inter-
preter, not linked structures. As we learned in Chapter 6, though, Python always
follows a reference to an object whenever the reference is used, so your program
deals only with objects. Whenever you assign an object to a data structure com-
ponent or variable name, Python always stores a reference to that same object, not
a copy of it (unless you request a copy explicitly).
As a preview and reference, Table 8-1 summarizes common and representative list
object operations. It is fairly complete for Python 3.3, but for the full story, consult the
Python standard library manual, or run a help(list) or dir(list) call interactively for
a complete list of list methods—you can pass in a real list, or the word list, which is
the name of the list data type. The set of methods here is especially prone to change—
in fact, two are new as of Python 3.3.
Table 8-1. Common list literals and operations
Operation Interpretation
L = [] An empty list
L = [123, 'abc', 1.23, {}] Four items: indexes 0..3
L = ['Bob', 40.0, ['dev', 'mgr']] Nested sublists
L = list('spam')
L = list(range(-4, 4))
List of an iterable’s items, list of successive integers
L[i]
L[i][j]
L[i:j]
len(L)
Index, index of index, slice, length
L1 + L2 Concatenate, repeat
240 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-292-320.jpg)
![Operation Interpretation
L * 3
for x in L: print(x)
3 in L
Iteration, membership
L.append(4)
L.extend([5,6,7])
L.insert(i, X)
Methods: growing
L.index(X)
L.count(X)
Methods: searching
L.sort()
L.reverse()
L.copy()
L.clear()
Methods: sorting, reversing,
copying (3.3+), clearing (3.3+)
L.pop(i)
L.remove(X)
del L[i]
del L[i:j]
L[i:j] = []
Methods, statements: shrinking
L[i] = 3
L[i:j] = [4,5,6]
Index assignment, slice assignment
L = [x**2 for x in range(5)]
list(map(ord, 'spam'))
List comprehensions and maps (Chapter 4, Chapter 14, Chapter 20)
When written down as a literal expression, a list is coded as a series of objects (really,
expressions that return objects) in square brackets, separated by commas. For instance,
the second row in Table 8-1 assigns the variable L to a four-item list. A nested list is
coded as a nested square-bracketed series (row 3), and the empty list is just a square-
bracket pair with nothing inside (row 1).1
Many of the operations in Table 8-1 should look familiar, as they are the same sequence
operations we put to work on strings earlier—indexing, concatenation, iteration, and
so on. Lists also respond to list-specific method calls (which provide utilities such as
sorting, reversing, adding items to the end, etc.), as well as in-place change operations
1. In practice, you won’t see many lists written out like this in list-processing programs. It’s more common
to see code that processes lists constructed dynamically (at runtime), from user inputs, file contents, and
so on. In fact, although it’s important to master literal syntax, many data structures in Python are built
by running program code at runtime.
Lists | 241](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-293-320.jpg)
![(deleting items, assignment to indexes and slices, and so forth). Lists have these tools
for change operations because they are a mutable object type.
Lists in Action
Perhaps the best way to understand lists is to see them at work. Let’s once again turn
to some simple interpreter interactions to illustrate the operations in Table 8-1.
Basic List Operations
Because they are sequences, lists support many of the same operations as strings. For
example, lists respond to the + and * operators much like strings—they mean concat-
enation and repetition here too, except that the result is a new list, not a string:
% python
>>> len([1, 2, 3]) # Length
3
>>> [1, 2, 3] + [4, 5, 6] # Concatenation
[1, 2, 3, 4, 5, 6]
>>> ['Ni!'] * 4 # Repetition
['Ni!', 'Ni!', 'Ni!', 'Ni!']
Although the + operator works the same for lists and strings, it’s important to know
that it expects the same sort of sequence on both sides—otherwise, you get a type error
when the code runs. For instance, you cannot concatenate a list and a string unless you
first convert the list to a string (using tools such as str or % formatting) or convert the
string to a list (the list built-in function does the trick):
>>> str([1, 2]) + "34" # Same as "[1, 2]" + "34"
'[1, 2]34'
>>> [1, 2] + list("34") # Same as [1, 2] + ["3", "4"]
[1, 2, '3', '4']
List Iteration and Comprehensions
More generally, lists respond to all the sequence operations we used on strings in the
prior chapter, including iteration tools:
>>> 3 in [1, 2, 3] # Membership
True
>>> for x in [1, 2, 3]:
... print(x, end=' ') # Iteration (2.X uses: print x,)
...
1 2 3
We will talk more formally about for iteration and the range built-ins of Table 8-1 in
Chapter 13, because they are related to statement syntax. In short, for loops step
through items in any sequence from left to right, executing one or more statements for
each item; range produces successive integers.
242 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-294-320.jpg)
![The last items in Table 8-1, list comprehensions and map calls, are covered in more detail
in Chapter 14 and expanded on in Chapter 20. Their basic operation is straightforward,
though—as introduced in Chapter 4, list comprehensions are a way to build a new list
by applying an expression to each item in a sequence (really, in any iterable), and are
close relatives to for loops:
>>> res = [c * 4 for c in 'SPAM'] # List comprehensions
>>> res
['SSSS', 'PPPP', 'AAAA', 'MMMM']
This expression is functionally equivalent to a for loop that builds up a list of results
manually, but as we’ll learn in later chapters, list comprehensions are simpler to code
and likely faster to run today:
>>> res = []
>>> for c in 'SPAM': # List comprehension equivalent
... res.append(c * 4)
...
>>> res
['SSSS', 'PPPP', 'AAAA', 'MMMM']
As also introduced briefly in Chapter 4, the map built-in function does similar work, but
applies a function to items in a sequence and collects all the results in a new list:
>>> list(map(abs, [−1, −2, 0, 1, 2])) # Map a function across a sequence
[1, 2, 0, 1, 2]
Because we’re not quite ready for the full iteration story, we’ll postpone further details
for now, but watch for a similar comprehension expression for dictionaries later in this
chapter.
Indexing, Slicing, and Matrixes
Because lists are sequences, indexing and slicing work the same way for lists as they do
for strings. However, the result of indexing a list is whatever type of object lives at the
offset you specify, while slicing a list always returns a new list:
>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[2] # Offsets start at zero
'SPAM!'
>>> L[−2] # Negative: count from the right
'Spam'
>>> L[1:] # Slicing fetches sections
['Spam', 'SPAM!']
One note here: because you can nest lists and other object types within lists, you will
sometimes need to string together index operations to go deeper into a data structure.
For example, one of the simplest ways to represent matrixes (multidimensional arrays)
in Python is as lists with nested sublists. Here’s a basic 3 × 3 two-dimensional list-based
array:
>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Lists in Action | 243](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-295-320.jpg)
![With one index, you get an entire row (really, a nested sublist), and with two, you get
an item within the row:
>>> matrix[1]
[4, 5, 6]
>>> matrix[1][1]
5
>>> matrix[2][0]
7
>>> matrix = [[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]]
>>> matrix[1][1]
5
Notice in the preceding interaction that lists can naturally span multiple lines if you
want them to because they are contained by a pair of brackets; the “...”s here are
Python’s continuation line prompt (see Chapter 4 for comparable code without the
“...”s, and watch for more on syntax in the next part of the book).
For more on matrixes, watch later in this chapter for a dictionary-based matrix repre-
sentation, which can be more efficient when matrixes are largely empty. We’ll also
continue this thread in Chapter 20 where we’ll write additional matrix code, especially
with list comprehensions. For high-powered numeric work, the NumPy extension
mentioned in Chapter 4 and Chapter 5 provides other ways to handle matrixes.
Changing Lists in Place
Because lists are mutable, they support operations that change a list object in place.
That is, the operations in this section all modify the list object directly—overwriting
its former value—without requiring that you make a new copy, as you had to for strings.
Because Python deals only in object references, this distinction between changing an
object in place and creating a new object matters; as discussed in Chapter 6, if you
change an object in place, you might impact more than one reference to it at the same
time.
Index and slice assignments
When using a list, you can change its contents by assigning to either a particular item
(offset) or an entire section (slice):
>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[1] = 'eggs' # Index assignment
>>> L
['spam', 'eggs', 'SPAM!']
>>> L[0:2] = ['eat', 'more'] # Slice assignment: delete+insert
>>> L # Replaces items 0,1
['eat', 'more', 'SPAM!']
244 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-296-320.jpg)
![Both index and slice assignments are in-place changes—they modify the subject list
directly, rather than generating a new list object for the result. Index assignment in
Python works much as it does in C and most other languages: Python replaces the single
object reference at the designated offset with a new one.
Slice assignment, the last operation in the preceding example, replaces an entire section
of a list in a single step. Because it can be a bit complex, it is perhaps best thought of
as a combination of two steps:
1. Deletion. The slice you specify to the left of the = is deleted.
2. Insertion. The new items contained in the iterable object to the right of the = are
inserted into the list on the left, at the place where the old slice was deleted.2
This isn’t what really happens, but it can help clarify why the number of items inserted
doesn’t have to match the number of items deleted. For instance, given a list L of two
or more items, an assignment L[1:2]=[4,5] replaces one item with two—Python first
deletes the one-item slice at [1:2] (from offset 1, up to but not including offset 2), then
inserts both 4 and 5 where the deleted slice used to be.
This also explains why the second slice assignment in the following is really an insert
—Python replaces an empty slice at [1:1] with two items; and why the third is really
a deletion—Python deletes the slice (the item at offset 1), and then inserts nothing:
>>> L = [1, 2, 3]
>>> L[1:2] = [4, 5] # Replacement/insertion
>>> L
[1, 4, 5, 3]
>>> L[1:1] = [6, 7] # Insertion (replace nothing)
>>> L
[1, 6, 7, 4, 5, 3]
>>> L[1:2] = [] # Deletion (insert nothing)
>>> L
[1, 7, 4, 5, 3]
In effect, slice assignment replaces an entire section, or “column,” all at once—even if
the column or its replacement is empty. Because the length of the sequence being as-
signed does not have to match the length of the slice being assigned to, slice assignment
can be used to replace (by overwriting), expand (by inserting), or shrink (by deleting)
the subject list. It’s a powerful operation, but frankly, one that you may not see very
often in practice. There are often more straightforward and mnemonic ways to replace,
insert, and delete (concatenation, and the insert, pop, and remove list methods, for
example), which Python programmers tend to prefer in practice.
2. This description requires elaboration when the value and the slice being assigned overlap:
L[2:5]=L[3:6], for instance, works fine because the value to be inserted is fetched before the deletion
happens on the left.
Lists in Action | 245](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-297-320.jpg)
![On the other hand, this operation can be used as a sort of in-place concatenation at the
front of the list—per the next section’s method coverage, something the list’s extend
does more mnemonically at list end:
>>> L = [1]
>>> L[:0] = [2, 3, 4] # Insert all at :0, an empty slice at front
>>> L
[2, 3, 4, 1]
>>> L[len(L):] = [5, 6, 7] # Insert all at len(L):, an empty slice at end
>>> L
[2, 3, 4, 1, 5, 6, 7]
>>> L.extend([8, 9, 10]) # Insert all at end, named method
>>> L
[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]
List method calls
Like strings, Python list objects also support type-specific method calls, many of which
change the subject list in place:
>>> L = ['eat', 'more', 'SPAM!']
>>> L.append('please') # Append method call: add item at end
>>> L
['eat', 'more', 'SPAM!', 'please']
>>> L.sort() # Sort list items ('S' < 'e')
>>> L
['SPAM!', 'eat', 'more', 'please']
Methods were introduced in Chapter 7. In brief, they are functions (really, object at-
tributes that reference functions) that are associated with and act upon particular ob-
jects. Methods provide type-specific tools; the list methods presented here, for instance,
are generally available only for lists.
Perhaps the most commonly used list method is append, which simply tacks a single
item (object reference) onto the end of the list. Unlike concatenation, append expects
you to pass in a single object, not a list. The effect of L.append(X) is similar to L+[X],
but while the former changes L in place, the latter makes a new list.3 The sort method
orders the list’s items here, but merits a section of its own.
More on sorting lists
Another commonly seen method, sort, orders a list in place; it uses Python standard
comparison tests (here, string comparisons, but applicable to every object type), and
3. Unlike + concatenation, append doesn’t have to generate new objects, so it’s usually faster than + too. You
can also mimic append with the clever slice assignments of the prior section: L[len(L):]=[X] is like
L.append(X), and L[:0]=[X] is like appending at the front of a list. Both delete an empty slice and insert
X, changing L in place quickly, like append. Both are arguably more complex than list methods, though.
For instance, L.insert(0, X) can also append an item to the front of a list, and seems noticeably more
mnemonic; L.insert(len(L), X) inserts one object at the end too, but unless you like typing, you might
as well use L.append(X)!
246 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-298-320.jpg)
![by default sorts in ascending order. You can modify sort behavior by passing in keyword
arguments—a special “name=value” syntax in function calls that specifies passing by
name and is often used for giving configuration options.
In sorts, the reverse argument allows sorts to be made in descending instead of as-
cending order, and the key argument gives a one-argument function that returns the
value to be used in sorting—the string object’s standard lower case converter in the
following (though its newer casefold may handle some types of Unicode text better):
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort() # Sort with mixed case
>>> L
['ABD', 'aBe', 'abc']
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower) # Normalize to lowercase
>>> L
['abc', 'ABD', 'aBe']
>>>
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower, reverse=True) # Change sort order
>>> L
['aBe', 'ABD', 'abc']
The sort key argument might also be useful when sorting lists of dictionaries, to pick
out a sort key by indexing each dictionary. We’ll study dictionaries later in this chapter,
and you’ll learn more about keyword function arguments in Part IV.
Comparison and sorts in 3.X: In Python 2.X, relative magnitude com-
parisons of differently typed objects (e.g., a string and a list) work—the
language defines a fixed ordering among different types, which is de-
terministic, if not aesthetically pleasing. That is, the ordering is based
on the names of the types involved: all integers are less than all strings,
for example, because "int" is less than "str". Comparisons never au-
tomatically convert types, except when comparing numeric type ob-
jects.
In Python 3.X, this has changed: magnitude comparison of mixed types
raises an exception instead of falling back on the fixed cross-type or-
dering. Because sorting uses comparisons internally, this means that
[1, 2, 'spam'].sort() succeeds in Python 2.X but will raise an excep-
tion in Python 3.X. Sorting mixed-types fails by proxy.
Python 3.X also no longer supports passing in an arbitrary comparison
function to sorts, to implement different orderings. The suggested work-
around is to use the key=func keyword argument to code value trans-
formations during the sort, and use the reverse=True keyword argument
to change the sort order to descending. These were the typical uses of
comparison functions in the past.
Lists in Action | 247](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-299-320.jpg)
![One warning here: beware that append and sort change the associated list object in
place, but don’t return the list as a result (technically, they both return a value called
None). If you say something like L=L.append(X), you won’t get the modified value of L
(in fact, you’ll lose the reference to the list altogether!). When you use attributes such
as append and sort, objects are changed as a side effect, so there’s no reason to reassign.
Partly because of such constraints, sorting is also available in recent Pythons as a built-
in function, which sorts any collection (not just lists) and returns a new list for the result
(instead of in-place changes):
>>> L = ['abc', 'ABD', 'aBe']
>>> sorted(L, key=str.lower, reverse=True) # Sorting built-in
['aBe', 'ABD', 'abc']
>>> L = ['abc', 'ABD', 'aBe']
>>> sorted([x.lower() for x in L], reverse=True) # Pretransform items: differs!
['abe', 'abd', 'abc']
Notice the last example here—we can convert to lowercase prior to the sort with a list
comprehension, but the result does not contain the original list’s values as it does with
the key argument. The latter is applied temporarily during the sort, instead of changing
the values to be sorted altogether. As we move along, we’ll see contexts in which the
sorted built-in can sometimes be more useful than the sort method.
Other common list methods
Like strings, lists have other methods that perform other specialized operations. For
instance, reverse reverses the list in-place, and the extend and pop methods insert mul-
tiple items at and delete an item from the end of the list, respectively. There is also a
reversed built-in function that works much like sorted and returns a new result object,
but it must be wrapped in a list call in both 2.X and 3.X here because its result is an
iterator that produces results on demand (more on iterators later):
>>> L = [1, 2]
>>> L.extend([3, 4, 5]) # Add many items at end (like in-place +)
>>> L
[1, 2, 3, 4, 5]
>>> L.pop() # Delete and return last item (by default: −1)
5
>>> L
[1, 2, 3, 4]
>>> L.reverse() # In-place reversal method
>>> L
[4, 3, 2, 1]
>>> list(reversed(L)) # Reversal built-in with a result (iterator)
[1, 2, 3, 4]
Technically, the extend method always iterates through and adds each item in an itera-
ble object, whereas append simply adds a single item as is without iterating through it
—a distinction that will be more meaningful by Chapter 14. For now, it’s enough to
know that extend adds many items, and append adds one. In some types of programs,
248 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-300-320.jpg)
![the list pop method is often used in conjunction with append to implement a quick last-
in-first-out (LIFO) stack structure. The end of the list serves as the top of the stack:
>>> L = []
>>> L.append(1) # Push onto stack
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop() # Pop off stack
2
>>> L
[1]
The pop method also accepts an optional offset of the item to be deleted and returned
(the default is the last item at offset −1). Other list methods remove an item by value
(remove), insert an item at an offset (insert), count the number of occurrences
(count), and search for an item’s offset (index—a search for the index of an item, not
to be confused with indexing!):
>>> L = ['spam', 'eggs', 'ham']
>>> L.index('eggs') # Index of an object (search/find)
1
>>> L.insert(1, 'toast') # Insert at position
>>> L
['spam', 'toast', 'eggs', 'ham']
>>> L.remove('eggs') # Delete by value
>>> L
['spam', 'toast', 'ham']
>>> L.pop(1) # Delete by position
'toast'
>>> L
['spam', 'ham']
>>> L.count('spam') # Number of occurrences
1
Note that unlike other list methods, count and index do not change the list itself, but
return information about its content. See other documentation sources or experiment
with these calls interactively on your own to learn more about list methods.
Other common list operations
Because lists are mutable, you can use the del statement to delete an item or section in
place:
>>> L = ['spam', 'eggs', 'ham', 'toast']
>>> del L[0] # Delete one item
>>> L
['eggs', 'ham', 'toast']
>>> del L[1:] # Delete an entire section
>>> L # Same as L[1:] = []
['eggs']
As we saw earlier, because slice assignment is a deletion plus an insertion, you can also
delete a section of a list by assigning an empty list to a slice (L[i:j]=[]); Python deletes
Lists in Action | 249](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-301-320.jpg)
![the slice named on the left, and then inserts nothing. Assigning an empty list to an
index, on the other hand, just stores a reference to the empty list object in the specified
slot, rather than deleting an item:
>>> L = ['Already', 'got', 'one']
>>> L[1:] = []
>>> L
['Already']
>>> L[0] = []
>>> L
[[]]
Although all the operations just discussed are typical, there may be additional list
methods and operations not illustrated here. The method set, for example, may change
over time, and in fact has in Python 3.3—its new L.copy() method makes a top-level
copy of the list, much like L[:] and list(L), but is symmetric with copy in sets and
dictionaries. For a comprehensive and up-to-date list of type tools, you should always
consult Python’s manuals, Python’s dir and help functions (which we first met in
Chapter 4), or one of the reference texts mentioned in the preface.
And because it’s such a common hurdle, I’d also like to remind you again that all the
in-place change operations discussed here work only for mutable objects: they won’t
work on strings (or tuples, discussed in Chapter 9), no matter how hard you try. Mu-
tability is an inherent property of each object type.
Dictionaries
Along with lists, dictionaries are one of the most flexible built-in data types in Python.
If you think of lists as ordered collections of objects, you can think of dictionaries as
unordered collections; the chief distinction is that in dictionaries, items are stored and
fetched by key, instead of by positional offset. While lists can serve roles similar to
arrays in other languages, dictionaries take the place of records, search tables, and any
other sort of aggregation where item names are more meaningful than item positions.
For example, dictionaries can replace many of the searching algorithms and data struc-
tures you might have to implement manually in lower-level languages—as a highly
optimized built-in type, indexing a dictionary is a very fast search operation. Diction-
aries also sometimes do the work of records, structs, and symbol tables used in other
languages; can be used to represent sparse (mostly empty) data structures; and much
more. Here’s a rundown of their main properties. Python dictionaries are:
Accessed by key, not offset position
Dictionaries are sometimes called associative arrays or hashes (especially by users
of other scripting languages). They associate a set of values with keys, so you can
fetch an item out of a dictionary using the key under which you originally stored
it. You use the same indexing operation to get components in a dictionary as you
do in a list, but the index takes the form of a key, not a relative offset.
250 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-302-320.jpg)
![Table 8-2. Common dictionary literals and operations
Operation Interpretation
D = {} Empty dictionary
D = {'name': 'Bob', 'age': 40} Two-item dictionary
E = {'cto': {'name': 'Bob', 'age': 40}} Nesting
D = dict(name='Bob', age=40)
D = dict([('name', 'Bob'), ('age', 40)])
D = dict(zip(keyslist, valueslist))
D = dict.fromkeys(['name', 'age'])
Alternative construction techniques:
keywords, key/value pairs, zipped key/value pairs, key lists
D['name']
E['cto']['age']
Indexing by key
'age' in D Membership: key present test
D.keys()
D.values()
D.items()
D.copy()
D.clear()
D.update(D2)
D.get(key, default?)
D.pop(key, default?)
D.setdefault(key, default?)
D.popitem()
Methods: all keys,
all values,
all key+value tuples,
copy (top-level),
clear (remove all items),
merge by keys,
fetch by key, if absent default (or None),
remove by key, if absent default (or error)
fetch by key, if absent set default (or None),
remove/return any (key, value) pair; etc.
len(D) Length: number of stored entries
D[key] = 42 Adding/changing keys
del D[key] Deleting entries by key
list(D.keys())
D1.keys() & D2.keys()
Dictionary views (Python 3.X)
D.viewkeys(), D.viewvalues() Dictionary views (Python 2.7)
D = {x: x*2 for x in range(10)} Dictionary comprehensions (Python 3.X, 2.7)
Dictionaries in Action
As Table 8-2 suggests, dictionaries are indexed by key, and nested dictionary entries
are referenced by a series of indexes (keys in square brackets). When Python creates a
dictionary, it stores its items in any left-to-right order it chooses; to fetch a value back,
252 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-304-320.jpg)
![you supply the key with which it is associated, not its relative position. Let’s go back
to the interpreter to get a feel for some of the dictionary operations in Table 8-2.
Basic Dictionary Operations
In normal operation, you create dictionaries with literals and store and access items by
key with indexing:
% python
>>> D = {'spam': 2, 'ham': 1, 'eggs': 3} # Make a dictionary
>>> D['spam'] # Fetch a value by key
2
>>> D # Order is "scrambled"
{'eggs': 3, 'spam': 2, 'ham': 1}
Here, the dictionary is assigned to the variable D; the value of the key 'spam' is the
integer 2, and so on. We use the same square bracket syntax to index dictionaries by
key as we did to index lists by offset, but here it means access by key, not by position.
Notice the end of this example—much like sets, the left-to-right order of keys in a
dictionary will almost always be different from what you originally typed. This is on
purpose: to implement fast key lookup (a.k.a. hashing), keys need to be reordered in
memory. That’s why operations that assume a fixed left-to-right order (e.g., slicing,
concatenation) do not apply to dictionaries; you can fetch values only by key, not by
position. Technically, the ordering is pseudo-random—it’s not truly random (you might
be able to decipher it given Python’s source code and a lot of time to kill), but it’s
arbitrary, and might vary per release and platform, and even per interactive session in
Python 3.3.
The built-in len function works on dictionaries, too; it returns the number of items
stored in the dictionary or, equivalently, the length of its keys list. The dictionary in
membership operator allows you to test for key existence, and the keys method returns
all the keys in the dictionary. The latter of these can be useful for processing dictionaries
sequentially, but you shouldn’t depend on the order of the keys list. Because the keys
result can be used as a normal list, however, it can always be sorted if order matters
(more on sorting and dictionaries later):
>>> len(D) # Number of entries in dictionary
3
>>> 'ham' in D # Key membership test alternative
True
>>> list(D.keys()) # Create a new list of D's keys
['eggs', 'spam', 'ham']
Observe the second expression in this listing. As mentioned earlier, the in membership
test used for strings and lists also works on dictionaries—it checks whether a key is
stored in the dictionary. Technically, this works because dictionaries define iterators
that step through their keys lists automatically. Other types provide iterators that reflect
Dictionaries in Action | 253](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-305-320.jpg)
![their common uses; files, for example, have iterators that read line by line. We’ll discuss
iterators more formally in Chapter 14 and Chapter 20.
Also note the syntax of the last example in this listing. We have to enclose it in a list
call in Python 3.X for similar reasons—keys in 3.X returns an iterable object, instead
of a physical list. The list call forces it to produce all its values at once so we can print
them interactively, though this call isn’t required some other contexts. In 2.X, keys
builds and returns an actual list, so the list call isn’t even needed to display a result;
more on this later in this chapter.
Changing Dictionaries in Place
Let’s continue with our interactive session. Dictionaries, like lists, are mutable, so you
can change, expand, and shrink them in place without making new dictionaries: simply
assign a value to a key to change or create an entry. The del statement works here, too;
it deletes the entry associated with the key specified as an index. Notice also the nesting
of a list inside a dictionary in this example (the value of the key 'ham'). All collection
data types in Python can nest inside each other arbitrarily:
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> D['ham'] = ['grill', 'bake', 'fry'] # Change entry (value=list)
>>> D
{'eggs': 3, 'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> del D['eggs'] # Delete entry
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> D['brunch'] = 'Bacon' # Add new entry
>>> D
{'brunch': 'Bacon', 'spam': 2, 'ham': ['grill', 'bake', 'fry']}
Like lists, assigning to an existing index in a dictionary changes its associated value.
Unlike lists, however, whenever you assign a new dictionary key (one that hasn’t been
assigned before) you create a new entry in the dictionary, as was done in the previous
example for the key 'brunch'. This doesn’t work for lists because you can only assign
to existing list offsets—Python considers an offset beyond the end of a list out of bounds
and raises an error. To expand a list, you need to use tools such as the append method
or slice assignment instead.
More Dictionary Methods
Dictionary methods provide a variety of type-specific tools. For instance, the dictionary
values and items methods return all of the dictionary’s values and (key,value) pair
tuples, respectively; along with keys, these are useful in loops that need to step through
dictionary entries one by one (we’ll start coding examples of such loops in the next
254 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-306-320.jpg)
![section). As for keys, these two methods also return iterable objects in 3.X, so wrap
them in a list call there to collect their values all at once for display:
>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> list(D.values())
[3, 2, 1]
>>> list(D.items())
[('eggs', 3), ('spam', 2), ('ham', 1)]
In realistic programs that gather data as they run, you often won’t be able to predict
what will be in a dictionary before the program is launched, much less when it’s coded.
Fetching a nonexistent key is normally an error, but the get method returns a default
value—None, or a passed-in default—if the key doesn’t exist. It’s an easy way to fill in
a default for a key that isn’t present, and avoid a missing-key error when your program
can’t anticipate contents ahead of time:
>>> D.get('spam') # A key that is there
2
>>> print(D.get('toast')) # A key that is missing
None
>>> D.get('toast', 88)
88
The update method provides something similar to concatenation for dictionaries,
though it has nothing to do with left-to-right ordering (again, there is no such thing in
dictionaries). It merges the keys and values of one dictionary into another, blindly
overwriting values of the same key if there’s a clash:
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> D2 = {'toast':4, 'muffin':5} # Lots of delicious scrambled order here
>>> D.update(D2)
>>> D
{'eggs': 3, 'muffin': 5, 'toast': 4, 'spam': 2, 'ham': 1}
Notice how mixed up the key order is in the last result; again, that’s just how diction-
aries work. Finally, the dictionary pop method deletes a key from a dictionary and re-
turns the value it had. It’s similar to the list pop method, but it takes a key instead of
an optional position:
# pop a dictionary by key
>>> D
{'eggs': 3, 'muffin': 5, 'toast': 4, 'spam': 2, 'ham': 1}
>>> D.pop('muffin')
5
>>> D.pop('toast') # Delete and return from a key
4
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
# pop a list by position
>>> L = ['aa', 'bb', 'cc', 'dd']
>>> L.pop() # Delete and return from the end
'dd'
Dictionaries in Action | 255](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-307-320.jpg)
![>>> L
['aa', 'bb', 'cc']
>>> L.pop(1) # Delete from a specific position
'bb'
>>> L
['aa', 'cc']
Dictionaries also provide a copy method; we’ll revisit this in Chapter 9, as it’s a way to
avoid the potential side effects of shared references to the same dictionary. In fact,
dictionaries come with more methods than those listed in Table 8-2; see the Python
library manual, dir and help, or other reference sources for a comprehensive list.
Your dictionary ordering may vary: Don’t be alarmed if your dictionaries
print in a different order than shown here. As mentioned, key order is
arbitrary, and might vary per release, platform, and interactive session
in 3.3 (and quite possibly per day of the week, and phase of the moon!).
Most of the dictionary examples in this book reflect Python 3.3’s key
ordering, but it has changed both since and prior to 3.0. Your Python’s
key order may vary, but you’re not supposed to care anyhow: diction-
aries are processed by key, not position. Programs shouldn’t rely on the
arbitrary order of keys in dictionaries, even if shown in books.
There are extension types in Python’s standard library that maintain
insertion order among their keys—see OrderedDict in the collections
module—but they are hybrids that incur extra space and speed over-
headstoachievetheirextrautility,andarenottruedictionaries.Inshort,
keys are kept redundantly in a linked list to support sequence opera-
tions.
As we’ll see in Chapter 9, this module also implements a namedtuple that
allows tuple items to be accessed by both attribute name and sequence
position—a sort of tuple/class/dictionary hybrid that adds processing
steps and is not a core object type in any event. Python’s library manual
has the full story on these and other extension types.
Example: Movie Database
Let’s look at a more realistic dictionary example. In honor of Python’s namesake, the
following example creates a simple in-memory Monty Python movie database, as a
table that maps movie release date years (the keys) to movie titles (the values). As coded,
you fetch movie names by indexing on release year strings:
>>> table = {'1975': 'Holy Grail', # Key: Value
... '1979': 'Life of Brian',
... '1983': 'The Meaning of Life'}
>>>
>>> year = '1983'
>>> movie = table[year] # dictionary[Key] => Value
>>> movie
'The Meaning of Life'
256 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-308-320.jpg)
![>>> for year in table: # Same as: for year in table.keys()
... print(year + 't' + table[year])
...
1979 Life of Brian
1975 Holy Grail
1983 The Meaning of Life
The last command uses a for loop, which we previewed in Chapter 4 but haven’t cov-
ered in detail yet. If you aren’t familiar with for loops, this command simply iterates
through each key in the table and prints a tab-separated list of keys and their values.
We’ll learn more about for loops in Chapter 13.
Dictionaries aren’t sequences like lists and strings, but if you need to step through the
items in a dictionary, it’s easy—calling the dictionary keys method returns all stored
keys, which you can iterate through with a for. If needed, you can index from key to
value inside the for loop as you go, as was done in this code.
In fact, Python also lets you step through a dictionary’s keys list without actually calling
the keys method in most for loops. For any dictionary D, saying for key in D works
the same as saying the completefor key in D.keys(). This is really just another instance
of the iterators mentioned earlier, which allow the in membership operator to work on
dictionaries as well; more on iterators later in this book.
Preview: Mapping values to keys
Notice how the prior table maps year to titles, but not vice versa. If you want to map
the other way—titles to years—you can either code the dictionary differently, or use
methods like items that give searchable sequences, though using them to best effect
requires more background information than we yet have:
>>> table = {'Holy Grail': '1975', # Key=>Value (title=>year)
... 'Life of Brian': '1979',
... 'The Meaning of Life': '1983'}
>>>
>>> table['Holy Grail']
'1975'
>>> list(table.items()) # Value=>Key (year=>title)
[('The Meaning of Life', '1983'), ('Holy Grail', '1975'), ('Life of Brian', '1979')]
>>> [title for (title, year) in table.items() if year == '1975']
['Holy Grail']
The last command here is in part a preview for the comprehension syntax introduced
in Chapter 4 and covered in full in Chapter 14. In short, it scans the dictionary’s (key,
value) tuple pairs returned by the items method, selecting keys having a specified value.
The net effect is to index backward—from value to key, instead of key to value—useful
if you want to store data just once and map backward only rarely (searching through
sequences like this is generally much slower than a direct key index).
Dictionaries in Action | 257](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-309-320.jpg)
![In fact, although dictionaries by nature map keys to values unidirectionally, there are
multiple ways to map values back to keys with a bit of extra generalizable code:
>>> K = 'Holy Grail'
>>> table[K] # Key=>Value (normal usage)
'1975'
>>> V = '1975'
>>> [key for (key, value) in table.items() if value == V] # Value=>Key
['Holy Grail']
>>> [key for key in table.keys() if table[key] == V] # Ditto
['Holy Grail']
Note that both of the last two commands return a list of titles: in dictionaries, there’s
just one value per key, but there may be many keys per value. A given value may be
stored under multiple keys (yielding multiple keys per value), and a value might be a
collection itself (supporting multiple values per key). For more on this front, also watch
for a dictionary inversion function in Chapter 32’s mapattrs.py example—code that
would surely stretch this preview past its breaking point if included here. For this
chapter’s purposes, let’s explore more dictionary basics.
Dictionary Usage Notes
Dictionaries are fairly straightforward tools once you get the hang of them, but here
are a few additional pointers and reminders you should be aware of when using them:
• Sequence operations don’t work. Dictionaries are mappings, not sequences; be-
cause there’s no notion of ordering among their items, things like concatenation
(an ordered joining) and slicing (extracting a contiguous section) simply don’t ap-
ply. In fact, Python raises an error when your code runs if you try to do such things.
• Assigning to new indexes adds entries. Keys can be created when you write a
dictionary literal (embedded in the code of the literal itself), or when you assign
values to new keys of an existing dictionary object individually. The end result is
the same.
• Keys need not always be strings. Our examples so far have used strings as keys,
but any other immutable objects work just as well. For instance, you can use inte-
gers as keys, which makes the dictionary look much like a list (when indexing, at
least). Tuples may be used as dictionary keys too, allowing compound key values
—such as dates and IP addresses—to have associated values. User-defined class
instance objects (discussed in Part VI) can also be used as keys, as long as they have
the proper protocol methods; roughly, they need to tell Python that their values
are “hashable” and thus won’t change, as otherwise they would be useless as fixed
keys. Mutable objects such as lists, sets, and other dictionaries don’t work as keys,
but are allowed as values.
258 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-310-320.jpg)
![Using dictionaries to simulate flexible lists: Integer keys
The last point in the prior list is important enough to demonstrate with a few examples.
When you use lists, it is illegal to assign to an offset that is off the end of the list:
>>> L = []
>>> L[99] = 'spam'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: list assignment index out of range
Although you can use repetition to preallocate as big a list as you’ll need (e.g.,
[0]*100), you can also do something that looks similar with dictionaries that does not
require such space allocations. By using integer keys, dictionaries can emulate lists that
seem to grow on offset assignment:
>>> D = {}
>>> D[99] = 'spam'
>>> D[99]
'spam'
>>> D
{99: 'spam'}
Here, it looks as if D is a 100-item list, but it’s really a dictionary with a single entry; the
value of the key 99 is the string 'spam'. You can access this structure with offsets much
like a list, catching nonexistent keys with get or in tests if required, but you don’t have
to allocate space for all the positions you might ever need to assign values to in the
future. When used like this, dictionaries are like more flexible equivalents of lists.
As another example, we might also employ integer keys in our first movie database’s
code earlier to avoid quoting the year, albeit at the expense of some expressiveness
(keys cannot contain nondigit characters):
>>> table = {1975: 'Holy Grail',
... 1979: 'Life of Brian', # Keys are integers, not strings
... 1983: 'The Meaning of Life'}
>>> table[1975]
'Holy Grail'
>>> list(table.items())
[(1979, 'Life of Brian'), (1983, 'The Meaning of Life'), (1975, 'Holy Grail')]
Using dictionaries for sparse data structures: Tuple keys
In a similar way, dictionary keys are also commonly leveraged to implement sparse data
structures—for example, multidimensional arrays where only a few positions have val-
ues stored in them:
>>> Matrix = {}
>>> Matrix[(2, 3, 4)] = 88
>>> Matrix[(7, 8, 9)] = 99
>>>
>>> X = 2; Y = 3; Z = 4 # ; separates statements: see Chapter 10
>>> Matrix[(X, Y, Z)]
88
Dictionaries in Action | 259](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-311-320.jpg)
![>>> Matrix
{(2, 3, 4): 88, (7, 8, 9): 99}
Here, we’ve used a dictionary to represent a three-dimensional array that is empty
except for the two positions (2,3,4) and (7,8,9). The keys are tuples that record the
coordinates of nonempty slots. Rather than allocating a large and mostly empty three-
dimensional matrix to hold these values, we can use a simple two-item dictionary. In
this scheme, accessing an empty slot triggers a nonexistent key exception, as these slots
are not physically stored:
>>> Matrix[(2,3,6)]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: (2, 3, 6)
Avoiding missing-key errors
Errors for nonexistent key fetches are common in sparse matrixes, but you probably
won’t want them to shut down your program. There are at least three ways to fill in a
default value instead of getting such an error message—you can test for keys ahead of
time in if statements, use a try statement to catch and recover from the exception
explicitly, or simply use the dictionary get method shown earlier to provide a default
for keys that do not exist. Consider the first two of these previews for statement syntax
we’ll begin studying in Chapter 10:
>>> if (2, 3, 6) in Matrix: # Check for key before fetch
... print(Matrix[(2, 3, 6)]) # See Chapters 10 and 12 for if/else
... else:
... print(0)
...
0
>>> try:
... print(Matrix[(2, 3, 6)]) # Try to index
... except KeyError: # Catch and recover
... print(0) # See Chapters 10 and 34 for try/except
...
0
>>> Matrix.get((2, 3, 4), 0) # Exists: fetch and return
88
>>> Matrix.get((2, 3, 6), 0) # Doesn't exist: use default arg
0
Of these, the get method is the most concise in terms of coding requirements, but the
if and try statements are much more general in scope; again, more on these starting
in Chapter 10.
Nesting in dictionaries
As you can see, dictionaries can play many roles in Python. In general, they can replace
search data structures (because indexing by key is a search operation) and can represent
many types of structured information. For example, dictionaries are one of many ways
260 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-312-320.jpg)
![to describe the properties of an item in your program’s domain; that is, they can serve
the same role as “records” or “structs” in other languages.
The following, for example, fills out a dictionary describing a hypothetical person, by
assigning to new keys over time (if you are a Bob, my apologies for picking on your
name in this book—it’s easy to type!):
>>> rec = {}
>>> rec['name'] = 'Bob'
>>> rec['age'] = 40.5
>>> rec['job'] = 'developer/manager'
>>>
>>> print(rec['name'])
Bob
Especially when nested, Python’s built-in data types allow us to easily represent struc-
tured information. The following again uses a dictionary to capture object properties,
but it codes it all at once (rather than assigning to each key separately) and nests a list
and a dictionary to represent structured property values:
>>> rec = {'name': 'Bob',
... 'jobs': ['developer', 'manager'],
... 'web': 'www.bobs.org/˜Bob',
... 'home': {'state': 'Overworked', 'zip': 12345}}
To fetch components of nested objects, simply string together indexing operations:
>>> rec['name']
'Bob'
>>> rec['jobs']
['developer', 'manager']
>>> rec['jobs'][1]
'manager'
>>> rec['home']['zip']
12345
Although we’ll learn in Part VI that classes (which group both data and logic) can be
better in this record role, dictionaries are an easy-to-use tool for simpler requirements.
For more on record representation choices, see also the upcoming sidebar “Why You
Will Care: Dictionaries Versus Lists” on page 263, as well as its extension to tuples in
Chapter 9 and classes in Chapter 27.
Also notice that while we’ve focused on a single “record” with nested data here, there’s
no reason we couldn’t nest the record itself in a larger, enclosing database collection
coded as a list or dictionary, though an external file or formal database interface often
plays the role of top-level container in realistic programs:
db = []
db.append(rec) # A list "database"
db.append(other)
db[0]['jobs']
db = {}
db['bob'] = rec # A dictionary "database"
Dictionaries in Action | 261](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-313-320.jpg)
![db['sue'] = other
db['bob']['jobs']
Later in the book we’ll meet tools such as Python’s shelve, which works much the same
way, but automatically maps objects to and from files to make them permanent (watch
for more in this chapter’s sidebar “Why You Will Care: Dictionary Inter-
faces” on page 271).
Other Ways to Make Dictionaries
Finally, note that because dictionaries are so useful, more ways to build them have
emerged over time. In Python 2.3 and later, for example, the last two calls to the dict
constructor (really, type name) shown here have the same effect as the literal and key-
assignment forms above them:
{'name': 'Bob', 'age': 40} # Traditional literal expression
D = {} # Assign by keys dynamically
D['name'] = 'Bob'
D['age'] = 40
dict(name='Bob', age=40) # dict keyword argument form
dict([('name', 'Bob'), ('age', 40)]) # dict key/value tuples form
All four of these forms create the same two-key dictionary, but they are useful in dif-
fering circumstances:
• The first is handy if you can spell out the entire dictionary ahead of time.
• The second is of use if you need to create the dictionary one field at a time on the
fly.
• The third involves less typing than the first, but it requires all keys to be strings.
• The last is useful if you need to build up keys and values as sequences at runtime.
We met keyword arguments earlier when sorting; the third form illustrated in this code
listing has become especially popular in Python code today, since it has less syntax (and
hence there is less opportunity for mistakes). As suggested previously in Table 8-2, the
last form in the listing is also commonly used in conjunction with the zip function, to
combine separate lists of keys and values obtained dynamically at runtime (parsed out
of a data file’s columns, for instance):
dict(zip(keyslist, valueslist)) # Zipped key/value tuples form (ahead)
More on zipping dictionary keys in the next section. Provided all the key’s values are
the same initially, you can also create a dictionary with this special form—simply pass
in a list of keys and an initial value for all of the values (the default is None):
>>> dict.fromkeys(['a', 'b'], 0)
{'a': 0, 'b': 0}
262 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-314-320.jpg)
![Although you could get by with just literals and key assignments at this point in your
Python career, you’ll probably find uses for all of these dictionary-creation forms as
you start applying them in realistic, flexible, and dynamic Python programs.
The listings in this section document the various ways to create dictionaries in both
Python 2.X and 3.X. However, there is yet another way to create dictionaries, available
only in Python 3.X and 2.7: the dictionary comprehension expression. To see how this
last form looks, we need to move on to the next and final section of this chapter.
Why You Will Care: Dictionaries Versus Lists
With all the objects in Python’s core types arsenal, some readers may be puzzled over
the choice between lists and dictionaries. In short, although both are flexible collections
of other objects, lists assign items to positions, and dictionaries assign them to more
mnemonic keys. Because of this, dictionary data often carries more meaning to human
readers. For example, the nested list structure in row 3 of Table 8-1 could be used to
represent a record too:
>>> L = ['Bob', 40.5, ['dev', 'mgr']] # List-based "record"
>>> L[0]
'Bob'
>>> L[1] # Positions/numbers for fields
40.5
>>> L[2][1]
'mgr'
For some types of data, the list’s access-by-position makes sense—a list of employees
in a company, the files in a directory, or numeric matrixes, for example. But a more
symbolic record like this may be more meaningfully coded as a dictionary along the
lines of row 2 in Table 8-2, with labeled fields replacing field positions (this is similar
to a record we coded in Chapter 4):
>>> D = {'name': 'Bob', 'age': 40.5, 'jobs': ['dev', 'mgr']}
>>> D['name']
'Bob'
>>> D['age'] # Dictionary-based "record"
40.5
>>> D['jobs'][1] # Names mean more than numbers
'mgr'
For variety, here is the same record recoded with keywords, which may seem even more
readable to some human readers:
>>> D = dict(name='Bob', age=40.5, jobs=['dev', 'mgr'])
>>> D['name']
'Bob'
>>> D['jobs'].remove('mgr')
>>> D
{'jobs': ['dev'], 'age': 40.5, 'name': 'Bob'}
In practice, dictionaries tend to be best for data with labeled components, as well as
structures that can benefit from quick, direct lookups by name, instead of slower linear
searches. As we’ve seen, they also may be better for sparse collections and collections
that grow at arbitrary positions.
Dictionaries in Action | 263](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-315-320.jpg)
![Python programmers also have access to the sets we studied in Chapter 5, which are
much like the keys of a valueless dictionary; they don’t map keys to values, but can
often be used like dictionaries for fast lookups when there is no associated value, es-
pecially in search routines:
>>> D = {}
>>> D['state1'] = True # A visited-state dictionary
>>> 'state1' in D
True
>>> S = set()
>>> S.add('state1') # Same, but with sets
>>> 'state1' in S
True
Watch for a rehash of this record representation thread in the next chapter, where we’ll
see how tuples and named tuples compare to dictionaries in this role, as well as in
Chapter 27, where we’ll learn how user-defined classes factor into this picture, com-
bining both data and logic to process it.
Dictionary Changes in Python 3.X and 2.7
This chapter has so far focused on dictionary basics that span releases, but the dictio-
nary’s functionality has mutated in Python 3.X. If you are using Python 2.X code, you
may come across some dictionary tools that either behave differently or are missing
altogether in 3.X. Moreover, 3.X coders have access to additional dictionary tools not
available in 2.X, apart from two back-ports to 2.7.
Specifically, dictionaries in Python 3.X:
• Support a new dictionary comprehension expression, a close cousin to list and set
comprehensions
• Return set-like iterable views instead of lists for the methods D.keys, D.values, and
D.items
• Require new coding styles for scanning by sorted keys, because of the prior point
• No longer support relative magnitude comparisons directly—compare manually
instead
• No longer have the D.has_key method—the in membership test is used instead
As later back-ports from 3.X, dictionaries in Python 2.7 (but not earlier in 2.X):
• Support item 1 in the prior list—dictionary comprehensions—as a direct back-port
from 3.X
• Support item 2 in the prior list—set-like iterable views—but do so with special
method names D.viewkeys, D.viewvalues, D.viewitems); their nonview methods
return lists as before
264 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-316-320.jpg)
![Because of this overlap, some of the material in this section pertains both to 3.X and
2.7, but is presented here in the context of 3.X extensions because of its origin. With
that in mind, let’s take a look at what’s new in dictionaries in 3.X and 2.7.
Dictionary comprehensions in 3.X and 2.7
As mentioned at the end of the prior section, dictionaries in 3.X and 2.7 can also be
created with dictionary comprehensions. Like the set comprehensions we met in
Chapter 5, dictionary comprehensions are available only in 3.X and 2.7 (not in 2.6 and
earlier). Like the longstanding list comprehensions we met briefly in Chapter 4 and
earlier in this chapter, they run an implied loop, collecting the key/value results of
expressions on each iteration and using them to fill out a new dictionary. A loop variable
allows the comprehension to use loop iteration values along the way.
To illustrate, a standard way to initialize a dictionary dynamically in both 2.X and 3.X
is to combine its keys and values with zip, and pass the result to the dict call. The
zip built-in function is the hook that allows us to construct a dictionary from key and
value lists this way—if you cannot predict the set of keys and values in your code, you
can always build them up as lists and zip them together. We’ll study zip in detail in
Chapter 13 and Chapter 14 after exploring statements; it’s an iterable in 3.X, so we
must wrap it in a list call to show its results there, but its basic usage is otherwise
straightforward:
>>> list(zip(['a', 'b', 'c'], [1, 2, 3])) # Zip together keys and values
[('a', 1), ('b', 2), ('c', 3)]
>>> D = dict(zip(['a', 'b', 'c'], [1, 2, 3])) # Make a dict from zip result
>>> D
{'b': 2, 'c': 3, 'a': 1}
In Python 3.X and 2.7, though, you can achieve the same effect with a dictionary com-
prehension expression. The following builds a new dictionary with a key/value pair for
every such pair in the zip result (it reads almost the same in Python, but with a bit more
formality):
>>> D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}
>>> D
{'b': 2, 'c': 3, 'a': 1}
Comprehensions actually require more code in this case, but they are also more general
than this example implies—we can use them to map a single stream of values to dic-
tionaries as well, and keys can be computed with expressions just like values:
>>> D = {x: x ** 2 for x in [1, 2, 3, 4]} # Or: range(1, 5)
>>> D
{1: 1, 2: 4, 3: 9, 4: 16}
>>> D = {c: c * 4 for c in 'SPAM'} # Loop over any iterable
>>> D
{'S': 'SSSS', 'P': 'PPPP', 'A': 'AAAA', 'M': 'MMMM'}
Dictionaries in Action | 265](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-317-320.jpg)
![>>> D = {c.lower(): c + '!' for c in ['SPAM', 'EGGS', 'HAM']}
>>> D
{'eggs': 'EGGS!', 'spam': 'SPAM!', 'ham': 'HAM!'}
Dictionary comprehensions are also useful for initializing dictionaries from keys lists,
in much the same way as the fromkeys method we met at the end of the preceding
section:
>>> D = dict.fromkeys(['a', 'b', 'c'], 0) # Initialize dict from keys
>>> D
{'b': 0, 'c': 0, 'a': 0}
>>> D = {k:0 for k in ['a', 'b', 'c']} # Same, but with a comprehension
>>> D
{'b': 0, 'c': 0, 'a': 0}
>>> D = dict.fromkeys('spam') # Other iterables, default value
>>> D
{'s': None, 'p': None, 'a': None, 'm': None}
>>> D = {k: None for k in 'spam'}
>>> D
{'s': None, 'p': None, 'a': None, 'm': None}
Like related tools, dictionary comprehensions support additional syntax not shown
here, including nested loops and if clauses. Unfortunately, to truly understand dictio-
nary comprehensions, we need to also know more about iteration statements and con-
cepts in Python, and we don’t yet have enough information to address that story well.
We’ll learn much more about all flavors of comprehensions (list, set, dictionary, and
generator) in Chapter 14 and Chapter 20, so we’ll defer further details until later. We’ll
also revisit the zip built-in we used in this section in more detail in Chapter 13, when
we explore for loops.
Dictionary views in 3.X (and 2.7 via new methods)
In 3.X the dictionary keys, values, and items methods all return view objects, whereas
in 2.X they return actual result lists. This functionality is also available in Python 2.7,
but in the guise of the special, distinct method names listed at the start of this section
(2.7’s normal methods still return simple lists, so as to avoid breaking existing 2.X
code); because of this, I’ll refer to this as a 3.X feature in this section.
View objects are iterables, which simply means objects that generate result items one
at a time, instead of producing the result list all at once in memory. Besides being
iterable, dictionary views also retain the original order of dictionary components, reflect
future changes to the dictionary, and may support set operations. On the other hand,
because they are not lists, they do not directly support operations like indexing or the
list sort method, and do not display their items as a normal list when printed (they do
show their components as of Python 3.1 but not as a list, and are still a divergence from
2.X).
266 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-318-320.jpg)
![We’ll discuss the notion of iterables more formally in Chapter 14, but for our purposes
here it’s enough to know that we have to run the results of these three methods through
the list built-in if we want to apply list operations or display their values. For example,
in Python 3.3 (other version’s outputs may differ slightly):
>>> D = dict(a=1, b=2, c=3)
>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> K = D.keys() # Makes a view object in 3.X, not a list
>>> K
dict_keys(['b', 'c', 'a'])
>>> list(K) # Force a real list in 3.X if needed
['b', 'c', 'a']
>>> V = D.values() # Ditto for values and items views
>>> V
dict_values([2, 3, 1])
>>> list(V)
[2, 3, 1]
>>> D.items()
dict_items([('b', 2), ('c', 3), ('a', 1)])
>>> list(D.items())
[('b', 2), ('c', 3), ('a', 1)]
>>> K[0] # List operations fail unless converted
TypeError: 'dict_keys' object does not support indexing
>>> list(K)[0]
'b'
Apart from result displays at the interactive prompt, you will probably rarely even
notice this change, because looping constructs in Python automatically force iterable
objects to produce one result on each iteration:
>>> for k in D.keys(): print(k) # Iterators used automatically in loops
...
b
c
a
In addition, 3.X dictionaries still have iterators themselves, which return successive
keys—as in 2.X, it’s still often not necessary to call keys directly:
>>> for key in D: print(key) # Still no need to call keys() to iterate
...
b
c
a
Unlike 2.X’s list results, though, dictionary views in 3.X are not carved in stone when
created—they dynamically reflect future changes made to the dictionary after the view
object has been created:
Dictionaries in Action | 267](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-319-320.jpg)
![>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> K = D.keys()
>>> V = D.values()
>>> list(K) # Views maintain same order as dictionary
['b', 'c', 'a']
>>> list(V)
[2, 3, 1]
>>> del D['b'] # Change the dictionary in place
>>> D
{'c': 3, 'a': 1}
>>> list(K) # Reflected in any current view objects
['c', 'a']
>>> list(V) # Not true in 2.X! - lists detached from dict
[3, 1]
Dictionary views and sets
Also unlike 2.X’s list results, 3.X’s view objects returned by the keys method are set-
like and support common set operations such as intersection and union; values views
are not set-like, but items results are if their (key, value) pairs are unique and hashable
(immutable). Given that sets behave much like valueless dictionaries (and may even be
coded in curly braces like dictionaries in 3.X and 2.7), this is a logical symmetry. Per
Chapter 5, set items are unordered, unique, and immutable, just like dictionary keys.
Here is what keys views look like when used in set operations (continuing the prior
section’s session); dictionary value views are never set-like, since their items are not
necessarily unique or immutable:
>>> K, V
(dict_keys(['c', 'a']), dict_values([3, 1]))
>>> K | {'x': 4} # Keys (and some items) views are set-like
{'c', 'x', 'a'}
>>> V & {'x': 4}
TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict'
>>> V & {'x': 4}.values()
TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict_values'
In set operations, views may be mixed with other views, sets, and dictionaries; dic-
tionaries are treated the same as their keys views in this context:
>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D.keys() & D.keys() # Intersect keys views
{'b', 'c', 'a'}
>>> D.keys() & {'b'} # Intersect keys and set
{'b'}
>>> D.keys() & {'b': 1} # Intersect keys and dict
{'b'}
268 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-320-320.jpg)
![>>> D.keys() | {'b', 'c', 'd'} # Union keys and set
{'b', 'c', 'a', 'd'}
Items views are set-like too if they are hashable—that is, if they contain only immutable
objects:
>>> D = {'a': 1}
>>> list(D.items()) # Items set-like if hashable
[('a', 1)]
>>> D.items() | D.keys() # Union view and view
{('a', 1), 'a'}
>>> D.items() | D # dict treated same as its keys
{('a', 1), 'a'}
>>> D.items() | {('c', 3), ('d', 4)} # Set of key/value pairs
{('d', 4), ('a', 1), ('c', 3)}
>>> dict(D.items() | {('c', 3), ('d', 4)}) # dict accepts iterable sets too
{'c': 3, 'a': 1, 'd': 4}
See Chapter 5’s coverage of sets if you need a refresher on these operations. Here, let’s
wrap up with three other quick coding notes for 3.X dictionaries.
Sorting dictionary keys in 3.X
First of all, because keys does not return a list in 3.X, the traditional coding pattern for
scanning a dictionary by sorted keys in 2.X won’t work in 3.X:
>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> Ks = D.keys() # Sorting a view object doesn't work!
>>> Ks.sort()
AttributeError: 'dict_keys' object has no attribute 'sort'
To work around this, in 3.X you must either convert to a list manually or use the
sorted call (introduced in Chapter 4 and covered in this chapter) on either a keys view
or the dictionary itself:
>>> Ks = list(Ks) # Force it to be a list and then sort
>>> Ks.sort()
>>> for k in Ks: print(k, D[k]) # 2.X: omit outer parens in prints
...
a 1
b 2
c 3
>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> Ks = D.keys() # Or you can use sorted() on the keys
>>> for k in sorted(Ks): print(k, D[k]) # sorted() accepts any iterable
... # sorted() returns its result
a 1
Dictionaries in Action | 269](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-321-320.jpg)
![b 2
c 3
Of these, using the dictionary’s keys iterator is probably preferable in 3.X, and works
in 2.X as well:
>>> D
{'b': 2, 'c': 3, 'a': 1} # Better yet, sort the dict directly
>>> for k in sorted(D): print(k, D[k]) # dict iterators return keys
...
a 1
b 2
c 3
Dictionary magnitude comparisons no longer work in 3.X
Secondly, while in Python 2.X dictionaries may be compared for relative magnitude
directly with <, >, and so on, in Python 3.X this no longer works. However, you can
simulate it by comparing sorted keys lists manually:
sorted(D1.items()) < sorted(D2.items()) # Like 2.X D1 < D2
Dictionary equality tests (e.g., D1 == D2) still work in 3.X, though. Since we’ll revisit
this near the end of the next chapter in the context of comparisons at large, we’ll post-
pone further details here.
The has_key method is dead in 3.X: Long live in!
Finally, the widely used dictionary has_key key presence test method is gone in 3.X.
Instead, use the in membership expression, or a get with a default test (of these, in is
generally preferred):
>>> D
{'b': 2, 'c': 3, 'a': 1}
>>> D.has_key('c') # 2.X only: True/False
AttributeError: 'dict' object has no attribute 'has_key'
>>> 'c' in D # Required in 3.X
True
>>> 'x' in D # Preferred in 2.X today
False
>>> if 'c' in D: print('present', D['c']) # Branch on result
...
present 3
>>> print(D.get('c')) # Fetch with default
3
>>> print(D.get('x'))
None
>>> if D.get('c') != None: print('present', D['c']) # Another option
...
present 3
270 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-322-320.jpg)
![To summarize, the dictionary story changes substantially in 3.X. If you work in 2.X
and care about 3.X compatibility (or suspect that you might someday), here are some
pointers. Of the 3.X changes we’ve met in this section:
• The first (dictionary comprehensions) can be coded only in 3.X and 2.7.
• The second (dictionary views) can be coded only in 3.X, and with special method
names in 2.7.
However, the last three techniques—sorted, manual comparisons, and in—can be
coded in 2.X today to ease 3.X migration in the future.
Why You Will Care: Dictionary Interfaces
Dictionaries aren’t just a convenient way to store information by key in your programs
—some Python extensions also present interfaces that look like and work the same as
dictionaries. For instance, Python’s interface to DBM access-by-key files looks much
like a dictionary that must be opened. You store and fetch strings using key indexes:
import dbm # Named anydbm in Python 2.X
file = dbm.open("filename") # Link to file
file['key'] = 'data' # Store data by key
data = file['key'] # Fetch data by key
In Chapter 28, you’ll see that you can store entire Python objects this way, too, if you
replace dbm in the preceding code with shelve (shelves are access-by-key databases that
store persistent Python objects, not just strings). For Internet work, Python’s CGI script
support also presents a dictionary-like interface. A call to cgi.FieldStorage yields a
dictionary-like object with one entry per input field on the client’s web page:
import cgi
form = cgi.FieldStorage() # Parse form data
if 'name' in form:
showReply('Hello, ' + form['name'].value)
Though dictionaries are the only core mapping type, all of these others are instances
of mappings, and support most of the same operations. Once you learn dictionary
interfaces, you’ll find that they apply to a variety of built-in tools in Python.
For another dictionary use case, see also Chapter 9’s upcoming overview of JSON—a
language-neutral data format used for databases and data transfer. Python dictionaries,
lists, and nested combinations of them can almost pass for records in this format as is,
and may be easily translated to and from formal JSON text strings with Python’s
json standard library module.
Chapter Summary
In this chapter, we explored the list and dictionary types—probably the two most
common, flexible, and powerful collection types you will see and use in Python code.
We learned that the list type supports positionally ordered collections of arbitrary ob-
Chapter Summary | 271](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-323-320.jpg)
![jects, and that it may be freely nested and grown and shrunk on demand. The dictionary
type is similar, but it stores items by key instead of by position and does not maintain
any reliable left-to-right order among its items. Both lists and dictionaries are mutable,
and so support a variety of in-place change operations not available for strings: for
example, lists can be grown by append calls, and dictionaries by assignment to new keys.
In the next chapter, we will wrap up our in-depth core object type tour by looking at
tuplesandfiles.Afterthat,we’llmoveontostatementsthatcodethelogicthatprocesses
our objects, taking us another step toward writing complete programs. Before we tackle
those topics, though, here are some chapter quiz questions to review.
Test Your Knowledge: Quiz
1. Name two ways to build a list containing five integer zeros.
2. Name two ways to build a dictionary with two keys, 'a' and 'b', each having an
associated value of 0.
3. Name four operations that change a list object in place.
4. Name four operations that change a dictionary object in place.
5. Why might you use a dictionary instead of a list?
Test Your Knowledge: Answers
1. A literal expression like [0, 0, 0, 0, 0] and a repetition expression like [0] * 5
will each create a list of five zeros. In practice, you might also build one up with a
loop that starts with an empty list and appends 0 to it in each iteration, with
L.append(0). A list comprehension ([0 for i in range(5)]) could work here, too,
but this is more work than you need to do for this answer.
2. A literal expression such as {'a': 0, 'b': 0} or a series of assignments like D =
{}, D['a'] = 0, and D['b'] = 0 would create the desired dictionary. You can also
use the newer and simpler-to-code dict(a=0, b=0) keyword form, or the more
flexible dict([('a', 0), ('b', 0)]) key/value sequences form. Or, because all the
values are the same, you can use the special form dict.fromkeys('ab', 0). In 3.X
and 2.7, you can also use a dictionary comprehension:{k:0 for k in 'ab'}, though
again, this may be overkill here.
3. The append and extend methods grow a list in place, the sort and reverse methods
order and reverse lists, the insert method inserts an item at an offset, the remove
and pop methods delete from a list by value and by position, the del statement
deletes an item or slice, and index and slice assignment statements replace an item
or entire section. Pick any four of these for the quiz.
4. Dictionaries are primarily changed by assignment to a new or existing key, which
creates or changes the key’s entry in the table. Also, the del statement deletes a
272 | Chapter 8: Lists and Dictionaries](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-324-320.jpg)
![Operation Interpretation
T = ('Bob', ('dev', 'mgr')) Nested tuples
T = tuple('spam') Tuple of items in an iterable
T[i]
T[i][j]
T[i:j]
len(T)
Index, index of index, slice, length
T1 + T2
T * 3
Concatenate, repeat
for x in T: print(x)
'spam' in T
[x ** 2 for x in T]
Iteration, membership
T.index('Ni')
T.count('Ni')
Methods in 2.6, 2.7, and 3.X: search, count
namedtuple('Emp', ['name', 'jobs']) Named tuple extension type
Tuples in Action
As usual, let’s start an interactive session to explore tuples at work. Notice in Ta-
ble 9-1 that tuples do not have all the methods that lists have (e.g., an append call won’t
work here). They do, however, support the usual sequence operations that we saw for
both strings and lists:
>>> (1, 2) + (3, 4) # Concatenation
(1, 2, 3, 4)
>>> (1, 2) * 4 # Repetition
(1, 2, 1, 2, 1, 2, 1, 2)
>>> T = (1, 2, 3, 4) # Indexing, slicing
>>> T[0], T[1:3]
(1, (2, 3))
Tuple syntax peculiarities: Commas and parentheses
The second and fourth entries in Table 9-1 merit a bit more explanation. Because
parentheses can also enclose expressions (see Chapter 5), you need to do something
special to tell Python when a single object in parentheses is a tuple object and not a
simple expression. If you really want a single-item tuple, simply add a trailing comma
after the single item, before the closing parenthesis:
>>> x = (40) # An integer!
>>> x
40
Tuples | 277](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-329-320.jpg)
![>>> y = (40,) # A tuple containing an integer
>>> y
(40,)
As a special case, Python also allows you to omit the opening and closing parentheses
for a tuple in contexts where it isn’t syntactically ambiguous to do so. For instance, the
fourth line of Table 9-1 simply lists four items separated by commas. In the context of
an assignment statement, Python recognizes this as a tuple, even though it doesn’t have
parentheses.
Now, some people will tell you to always use parentheses in your tuples, and some will
tell you to never use parentheses in tuples (and still others have lives, and won’t tell
you what to do with your tuples!). The most common places where the parentheses
are required for tuple literals are those where:
• Parentheses matter—within a function call, or nested in a larger expression.
• Commas matter—embedded in the literal of a larger data structure like a list or
dictionary, or listed in a Python 2.X print statement.
In most other contexts, the enclosing parentheses are optional. For beginners, the best
advice is that it’s probably easier to use the parentheses than it is to remember when
they are optional or required. Many programmers (myself included) also find that
parentheses tend to aid script readability by making the tuples more explicit and ob-
vious, but your mileage may vary.
Conversions, methods, and immutability
Apart from literal syntax differences, tuple operations (the middle rows in Table 9-1)
are identical to string and list operations. The only differences worth noting are that
the +, *, and slicing operations return new tuples when applied to tuples, and that tuples
don’t provide the same methods you saw for strings, lists, and dictionaries. If you want
to sort a tuple, for example, you’ll usually have to either first convert it to a list to gain
access to a sorting method call and make it a mutable object, or use the newer sorted
built-in that accepts any sequence object (and other iterables—a term introduced in
Chapter 4 that we’ll be more formal about in the next part of this book):
>>> T = ('cc', 'aa', 'dd', 'bb')
>>> tmp = list(T) # Make a list from a tuple's items
>>> tmp.sort() # Sort the list
>>> tmp
['aa', 'bb', 'cc', 'dd']
>>> T = tuple(tmp) # Make a tuple from the list's items
>>> T
('aa', 'bb', 'cc', 'dd')
>>> sorted(T) # Or use the sorted built-in, and save two steps
['aa', 'bb', 'cc', 'dd']
278 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-330-320.jpg)
![Here, the list and tuple built-in functions are used to convert the object to a list and
then back to a tuple; really, both calls make new objects, but the net effect is like a
conversion.
List comprehensions can also be used to convert tuples. The following, for example,
makes a list from a tuple, adding 20 to each item along the way:
>>> T = (1, 2, 3, 4, 5)
>>> L = [x + 20 for x in T]
>>> L
[21, 22, 23, 24, 25]
List comprehensions are really sequence operations—they always build new lists, but
they may be used to iterate over any sequence objects, including tuples, strings, and
other lists. As we’ll see later in the book, they even work on some things that are not
physically stored sequences—any iterable objects will do, including files, which are
automatically read line by line. Given this, they may be better called iteration tools.
Although tuples don’t have the same methods as lists and strings, they do have two of
their own as of Python 2.6 and 3.0—index and count work as they do for lists, but they
are defined for tuple objects:
>>> T = (1, 2, 3, 2, 4, 2) # Tuple methods in 2.6, 3.0, and later
>>> T.index(2) # Offset of first appearance of 2
1
>>> T.index(2, 2) # Offset of appearance after offset 2
3
>>> T.count(2) # How many 2s are there?
3
Prior to 2.6 and 3.0, tuples have no methods at all—this was an old Python convention
for immutable types, which was violated years ago on grounds of practicality with
strings, and more recently with both numbers and tuples.
Also, note that the rule about tuple immutability applies only to the top level of the
tupleitself,nottoitscontents.Alistinsideatuple,forinstance,canbechangedasusual:
>>> T = (1, [2, 3], 4)
>>> T[1] = 'spam' # This fails: can't change tuple itself
TypeError: object doesn't support item assignment
>>> T[1][0] = 'spam' # This works: can change mutables inside
>>> T
(1, ['spam', 3], 4)
For most programs, this one-level-deep immutability is sufficient for common tuple
roles. Which, coincidentally, brings us to the next section.
Why Lists and Tuples?
This seems to be the first question that always comes up when teaching beginners about
tuples: why do we need tuples if we have lists? Some of the reasoning may be historic;
Tuples | 279](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-331-320.jpg)
![Python’s creator is a mathematician by training, and he has been quoted as seeing a
tuple as a simple association of objects and a list as a data structure that changes over
time. In fact, this use of the word “tuple” derives from mathematics, as does its frequent
use for a row in a relational database table.
The best answer, however, seems to be that the immutability of tuples provides some
integrity—you can be sure a tuple won’t be changed through another reference else-
where in a program, but there’s no such guarantee for lists. Tuples and other immut-
ables, therefore, serve a similar role to “constant” declarations in other languages,
though the notion of constantness is associated with objects in Python, not variables.
Tuples can also be used in places that lists cannot—for example, as dictionary keys
(see the sparse matrix example in Chapter 8). Some built-in operations may also require
or imply tuples instead of lists (e.g., the substitution values in a string format expres-
sion), though such operations have often been generalized in recent years to be more
flexible. As a rule of thumb, lists are the tool of choice for ordered collections that might
need to change; tuples can handle the other cases of fixed associations.
Records Revisited: Named Tuples
In fact, the choice of data types is even richer than the prior section may have implied
—today’s Python programmers can choose from an assortment of both built-in core
types, and extension types built on top of them. For example, in the prior chapter’s
sidebar “Why You Will Care: Dictionaries Versus Lists” on page 263, we saw how to
represent record-like information with both a list and a dictionary, and noted that
dictionaries offer the advantage of more mnemonic keys that label data. As long as we
don’t require mutability, tuples can serve similar roles, with positions for record fields
like lists:
>>> bob = ('Bob', 40.5, ['dev', 'mgr']) # Tuple record
>>> bob
('Bob', 40.5, ['dev', 'mgr'])
>>> bob[0], bob[2] # Access by position
('Bob', ['dev', 'mgr'])
As for lists, though, field numbers in tuples generally carry less information than the
names of keys in a dictionary. Here’s the same record recoded as a dictionary with
named fields:
>>> bob = dict(name='Bob', age=40.5, jobs=['dev', 'mgr']) # Dictionary record
>>> bob
{'jobs': ['dev', 'mgr'], 'name': 'Bob', 'age': 40.5}
>>> bob['name'], bob['jobs'] # Access by key
('Bob', ['dev', 'mgr'])
In fact, we can convert parts of the dictionary to a tuple if needed:
280 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-332-320.jpg)
![>>> tuple(bob.values()) # Values to tuple
(['dev', 'mgr'], 'Bob', 40.5)
>>> list(bob.items()) # Items to tuple list
[('jobs', ['dev', 'mgr']), ('name', 'Bob'), ('age', 40.5)]
But with a bit of extra work, we can implement objects that offer both positional and
named access to record fields. For example, the namedtuple utility, available in the
standard library’s collections module mentioned in Chapter 8, implements an exten-
sion type that adds logic to tuples that allows components to be accessed by both
position and attribute name, and can be converted to dictionary-like form for access by
key if desired. Attribute names come from classes and are not exactly dictionary keys,
but they are similarly mnemonic:
>>> from collections import namedtuple # Import extension type
>>> Rec = namedtuple('Rec', ['name', 'age', 'jobs']) # Make a generated class
>>> bob = Rec('Bob', age=40.5, jobs=['dev', 'mgr']) # A named-tuple record
>>> bob
Rec(name='Bob', age=40.5, jobs=['dev', 'mgr'])
>>> bob[0], bob[2] # Access by position
('Bob', ['dev', 'mgr'])
>>> bob.name, bob.jobs # Access by attribute
('Bob', ['dev', 'mgr'])
Converting to a dictionary supports key-based behavior when needed:
>>> O = bob._asdict() # Dictionary-like form
>>> O['name'], O['jobs'] # Access by key too
('Bob', ['dev', 'mgr'])
>>> O
OrderedDict([('name', 'Bob'), ('age', 40.5), ('jobs', ['dev', 'mgr'])])
As you can see, named tuples are a tuple/class/dictionary hybrid. They also represent
a classic tradeoff. In exchange for their extra utility, they require extra code (the two
startup lines in the preceding examples that import the type and make the class), and
incur some performance costs to work this magic. (In short, named tuples build new
classes that extend the tuple type, inserting a property accessor method for each named
field that maps the name to its position—a technique that relies on advanced topics
we’ll explore in Part VIII, and uses formatted code strings instead of class annotation
tools like decorators and metaclasses.) Still, they are a good example of the kind of
custom data types that we can build on top of built-in types like tuples when extra
utility is desired.
Named tuples are available in Python 3.X, 2.7, 2.6 (where _asdict returns a true dic-
tionary), and perhaps earlier, though they rely on features relatively modern by Python
standards. They are also extensions, not core types—they live in the standard library
and fall into the same category as Chapter 5’s Fraction and Decimal—so we’ll delegate
to the Python library manual for more details.
As a quick preview, though, both tuples and named tuples support unpacking tuple
assignment, which we’ll study formally in Chapter 13, as well as the iteration contexts
Tuples | 281](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-333-320.jpg)
![we’ll explore in Chapter 14 and Chapter 20 (notice the positional initial values here:
named tuples accept these by name, position, or both):
>>> bob = Rec('Bob', 40.5, ['dev', 'mgr']) # For both tuples and named tuples
>>> name, age, jobs = bob # Tuple assignment (Chapter 11)
>>> name, jobs
('Bob', ['dev', 'mgr'])
>>> for x in bob: print(x) # Iteration context (Chapters 14, 20)
...prints Bob, 40.5, ['dev', 'mgr']...
Tuple-unpacking assignment doesn’t quite apply to dictionaries, short of fetching and
converting keys and values and assuming or imposing an positional ordering on them
(dictionaries are not sequences), and iteration steps through keys, not values (notice
the dictionary literal form here: an alternative to dict):
>>> bob = {'name': 'Bob', 'age': 40.5, 'jobs': ['dev', 'mgr']}
>>> job, name, age = bob.values()
>>> name, job # Dict equivalent (but order may vary)
('Bob', ['dev', 'mgr'])
>>> for x in bob: print(bob[x]) # Step though keys, index values
...prints values...
>>> for x in bob.values(): print(x) # Step through values view
...prints values...
Watch for a final rehash of this record representation thread when we see how user-
defined classes compare in Chapter 27; as we’ll find, classes label fields with names too,
but can also provide program logic to process the record’s data in the same package.
Files
You may already be familiar with the notion of files, which are named storage com-
partmentsonyourcomputerthataremanagedbyyouroperatingsystem.Thelastmajor
built-in object type that we’ll examine on our object types tour provides a way to access
those files inside Python programs.
In short, the built-in open function creates a Python file object, which serves as a link
to a file residing on your machine. After calling open, you can transfer strings of data
to and from the associated external file by calling the returned file object’s methods.
Compared to the types you’ve seen so far, file objects are somewhat unusual. They are
considered a core type because they are created by a built-in function, but they’re not
numbers, sequences, or mappings, and they don’t respond to expression operators;
they export only methods for common file-processing tasks. Most file methods are
concerned with performing input from and output to the external file associated with
a file object, but other file methods allow us to seek to a new position in the file, flush
output buffers, and so on. Table 9-2 summarizes common file operations.
282 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-334-320.jpg)
![>>> open('C:Python33Libpdb.py').readline()
'#! /usr/bin/env python3n'
The raw string form in the second command is still useful to turn off
accidental escapes when you can’t control string content, and in other
contexts.
Text and Binary Files: The Short Story
Strictly speaking, the example in the prior section uses text files. In both Python 3.X
and 2.X, file type is determined by the second argument to open, the mode string—an
included “b” means binary. Python has always supported both text and binary files,
but in Python 3.X there is a sharper distinction between the two:
• Text files represent content as normal str strings, perform Unicode encoding and
decoding automatically, and perform end-of-line translation by default.
• Binary files represent content as a special bytes string type and allow programs to
access file content unaltered.
In contrast, Python 2.X text files handle both 8-bit text and binary data, and a special
string type and file interface (unicode strings and codecs.open) handles Unicode text.
The differences in Python 3.X stem from the fact that simple and Unicode text have
been merged in the normal string type—which makes sense, given that all text is Uni-
code, including ASCII and other 8-bit encodings.
Because most programmers deal only with ASCII text, they can get by with the basic
text file interface used in the prior example, and normal strings. All strings are techni-
cally Unicode in 3.X, but ASCII users will not generally notice. In fact, text files and
strings work the same in 3.X and 2.X if your script’s scope is limited to such simple
forms of text.
If you need to handle internationalized applications or byte-oriented data, though, the
distinction in 3.X impacts your code (usually for the better). In general, you must use
bytes strings for binary files, and normal str strings for text files. Moreover, because
text files implement Unicode encodings, you should not open a binary data file in text
mode—decoding its content to Unicode text will likely fail.
Let’s look at an example. When you read a binary data file you get back a bytes object
—a sequence of small integers that represent absolute byte values (which may or may
not correspond to characters), which looks and feels almost exactly like a normal string.
In Python 3.X, and assuming an existing binary file:
>>> data = open('data.bin', 'rb').read() # Open binary file: rb=read binary
>>> data # bytes string holds binary data
b'x00x00x00x07spamx00x08'
>>> data[4:8] # Act like strings
b'spam'
>>> data[4:8][0] # But really are small 8-bit integers
115
Files | 287](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-339-320.jpg)
![>>> bin(data[4:8][0]) # Python 3.X/2.6+ bin() function
'0b1110011'
In addition, binary files do not perform any end-of-line translation on data; text files by
default map all forms to and from n when written and read and implement Unicode
encodings on transfers in 3.X. Binary files like this one work the same in Python 2.X,
but byte strings are simply normal strings and have no leading b when displayed, and
text files must use the codecs module to add Unicode processing.
Per the note at the start of this chapter, though, that’s as much as we’re going to say
about Unicode text and binary data files here, and just enough to understand upcoming
examples in this chapter. Since the distinction is of marginal interest to many Python
programmers, we’ll defer to the files preview in Chapter 4 for a quick tour and postpone
the full story until Chapter 37. For now, let’s move on to some more substantial file
examples to demonstrate a few common use cases.
Storing Python Objects in Files: Conversions
Our next example writes a variety of Python objects into a text file on multiple lines.
Notice that it must convert objects to strings using conversion tools. Again, file data is
always strings in our scripts, and write methods do not do any automatic to-string
formatting for us (for space, I’m omitting byte-count return values from write methods
from here on):
>>> X, Y, Z = 43, 44, 45 # Native Python objects
>>> S = 'Spam' # Must be strings to store in file
>>> D = {'a': 1, 'b': 2}
>>> L = [1, 2, 3]
>>>
>>> F = open('datafile.txt', 'w') # Create output text file
>>> F.write(S + 'n') # Terminate lines with n
>>> F.write('%s,%s,%sn' % (X, Y, Z)) # Convert numbers to strings
>>> F.write(str(L) + '$' + str(D) + 'n') # Convert and separate with $
>>> F.close()
Once we have created our file, we can inspect its contents by opening it and reading it
into a string (strung together as a single operation here). Notice that the interactive
echo gives the exact byte contents, while the print operation interprets embedded end-
of-line characters to render a more user-friendly display:
>>> chars = open('datafile.txt').read() # Raw string display
>>> chars
"Spamn43,44,45n[1, 2, 3]${'a': 1, 'b': 2}n"
>>> print(chars) # User-friendly display
Spam
43,44,45
[1, 2, 3]${'a': 1, 'b': 2}
We now have to use other conversion tools to translate from the strings in the text file
to real Python objects. As Python never converts strings to numbers (or other types of
288 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-340-320.jpg)
![objects) automatically, this is required if we need to gain access to normal object tools
like indexing, addition, and so on:
>>> F = open('datafile.txt') # Open again
>>> line = F.readline() # Read one line
>>> line
'Spamn'
>>> line.rstrip() # Remove end-of-line
'Spam'
For this first line, we used the string rstrip method to get rid of the trailing end-of-line
character; a line[:−1] slice would work, too, but only if we can be sure all lines end in
the n character (the last line in a file sometimes does not).
So far, we’ve read the line containing the string. Now let’s grab the next line, which
contains numbers, and parse out (that is, extract) the objects on that line:
>>> line = F.readline() # Next line from file
>>> line # It's a string here
'43,44,45n'
>>> parts = line.split(',') # Split (parse) on commas
>>> parts
['43', '44', '45n']
We used the string split method here to chop up the line on its comma delimiters; the
result is a list of substrings containing the individual numbers. We still must convert
from strings to integers, though, if we wish to perform math on these:
>>> int(parts[1]) # Convert from string to int
44
>>> numbers = [int(P) for P in parts] # Convert all in list at once
>>> numbers
[43, 44, 45]
As we have learned, int translates a string of digits into an integer object, and the list
comprehension expression introduced in Chapter 4 can apply the call to each item in
our list all at once (you’ll find more on list comprehensions later in this book). Notice
that we didn’t have to run rstrip to delete the n at the end of the last part; int and
some other converters quietly ignore whitespace around digits.
Finally, to convert the stored list and dictionary in the third line of the file, we can run
them through eval, a built-in function that treats a string as a piece of executable pro-
gram code (technically, a string containing a Python expression):
>>> line = F.readline()
>>> line
"[1, 2, 3]${'a': 1, 'b': 2}n"
>>> parts = line.split('$') # Split (parse) on $
>>> parts
['[1, 2, 3]', "{'a': 1, 'b': 2}n"]
>>> eval(parts[0]) # Convert to any object type
[1, 2, 3]
>>> objects = [eval(P) for P in parts] # Do same for all in list
Files | 289](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-341-320.jpg)
![>>> objects
[[1, 2, 3], {'a': 1, 'b': 2}]
Because the end result of all this parsing and converting is a list of normal Python objects
instead of strings, we can now apply list and dictionary operations to them in our script.
Storing Native Python Objects: pickle
Using eval to convert from strings to objects, as demonstrated in the preceding code,
is a powerful tool. In fact, sometimes it’s too powerful. eval will happily run any Python
expression—even one that might delete all the files on your computer, given the nec-
essary permissions! If you really want to store native Python objects, but you can’t trust
the source of the data in the file, Python’s standard library pickle module is ideal.
The pickle module is a more advanced tool that allows us to store almost any Python
object in a file directly, with no to- or from-string conversion requirement on our part.
It’s like a super-general data formatting and parsing utility. To store a dictionary in a
file, for instance, we pickle it directly:
>>> D = {'a': 1, 'b': 2}
>>> F = open('datafile.pkl', 'wb')
>>> import pickle
>>> pickle.dump(D, F) # Pickle any object to file
>>> F.close()
Then, to get the dictionary back later, we simply use pickle again to re-create it:
>>> F = open('datafile.pkl', 'rb')
>>> E = pickle.load(F) # Load any object from file
>>> E
{'a': 1, 'b': 2}
We get back an equivalent dictionary object, with no manual splitting or converting
required. The pickle module performs what is known as object serialization—convert-
ing objects to and from strings of bytes—but requires very little work on our part. In
fact, pickle internally translates our dictionary to a string form, though it’s not much
to look at (and may vary if we pickle in other data protocol modes):
>>> open('datafile.pkl', 'rb').read() # Format is prone to change!
b'x80x03}qx00(Xx01x00x00x00bqx01Kx02Xx01x00x00x00aqx02Kx01u.'
Because pickle can reconstruct the object from this format, we don’t have to deal with
it ourselves. For more on the pickle module, see the Python standard library manual,
or import pickle and pass it to help interactively. While you’re exploring, also take a
look at the shelve module. shelve is a tool that uses pickle to store Python objects in
an access-by-key filesystem, which is beyond our scope here (though you will get to see
an example of shelve in action in Chapter 28, and other pickle examples in Chap-
ter 31 and Chapter 37).
290 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-342-320.jpg)
![Notice that I opened the file used to store the pickled object in binary
mode; binary mode is always required in Python 3.X, because the pickler
creates and uses a bytes string object, and these objects imply binary-
mode files (text-mode files imply str strings in 3.X). In earlier Pythons
it’s OK to use text-mode files for protocol 0 (the default, which creates
ASCII text), as long as text mode is used consistently; higher protocols
require binary-mode files. Python 3.X’s default protocol is 3 (binary),
but it creates bytes even for protocol 0. See Chapter 28, Chapter 31, and
Chapter37;Python’slibrarymanual;orreferencebooksformoredetails
on and examples of pickled data.
Python 2.X also has a cPickle module, which is an optimized version of
pickle that can be imported directly for speed. Python 3.X renames this
module _pickle and uses it automatically in pickle—scripts simply im-
port pickle and let Python optimize itself.
Storing Python Objects in JSON Format
The prior section’s pickle module translates nearly arbitrary Python objects to a pro-
prietary format developed specifically for Python, and honed for performance over
many years. JSON is a newer and emerging data interchange format, which is both
programming-language-neutral and supported by a variety of systems. MongoDB, for
instance, stores data in a JSON document database (using a binary JSON format).
JSON does not support as broad a range of Python object types as pickle, but its
portability is an advantage in some contexts, and it represents another way to serialize
a specific category of Python objects for storage and transmission. Moreover, because
JSON is so close to Python dictionaries and lists in syntax, the translation to and from
Python objects is trivial, and is automated by the json standard library module.
For example, a Python dictionary with nested structures is very similar to JSON data,
though Python’s variables and expressions support richer structuring options (any part
of the following can be an arbitrary expression in Python code):
>>> name = dict(first='Bob', last='Smith')
>>> rec = dict(name=name, job=['dev', 'mgr'], age=40.5)
>>> rec
{'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5}
The final dictionary format displayed here is a valid literal in Python code, and almost
passes for JSON when printed as is, but the json module makes the translation official
—here translating Python objects to and from a JSON serialized string representation
in memory:
>>> import json
>>> json.dumps(rec)
'{"job": ["dev", "mgr"], "name": {"last": "Smith", "first": "Bob"}, "age": 40.5}'
>>> S = json.dumps(rec)
>>> S
Files | 291](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-343-320.jpg)
!['{"job": ["dev", "mgr"], "name": {"last": "Smith", "first": "Bob"}, "age": 40.5}'
>>> O = json.loads(S)
>>> O
{'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5}
>>> O == rec
True
It’s similarly straightforward to translate Python objects to and from JSON data strings
in files. Prior to being stored in a file, your data is simply Python objects; the JSON
module recreates them from the JSON textual representation when it loads it from the
file:
>>> json.dump(rec, fp=open('testjson.txt', 'w'), indent=4)
>>> print(open('testjson.txt').read())
{
"job": [
"dev",
"mgr"
],
"name": {
"last": "Smith",
"first": "Bob"
},
"age": 40.5
}
>>> P = json.load(open('testjson.txt'))
>>> P
{'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5}
Once you’ve translated from JSON text, you process the data using normal Python
object operations in your script. For more details on JSON-related topics, see Python’s
library manuals and search the Web.
Note that strings are all Unicode in JSON to support text drawn from international
character sets, so you’ll see a leading u on strings after translating from JSON data in
Python 2.X (but not in 3.X); this is just the syntax of Unicode objects in 2.X, as intro-
duced Chapter 4 and Chapter 7, and covered in full in Chapter 37. Because Unicode
text strings support all the usual string operations, the difference is negligible to your
code while text resides in memory; the distinction matters most when transferring text
to and from files, and then usually only for non-ASCII types of text where encodings
come into play.
There is also support in the Python world for translating objects to and
from XML, a text format used in Chapter 37; see the web for details.For
another semirelated tool that deals with formatted data files, see the
standard library’s csv module. It parses and creates CSV (comma-sep-
arated value) data in files and strings. This doesn’t map as directly to
Python objects, but is another common data exchange format:
>>> import csv
>>> rdr = csv.reader(open('csvdata.txt'))
292 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-344-320.jpg)
![>>> for row in rdr: print(row)
...
['a', 'bbb', 'cc', 'dddd']
['11', '22', '33', '44']
Storing Packed Binary Data: struct
One other file-related note before we move on: some advanced applications also need
to deal with packed binary data, created perhaps by a C language program or a network
connection. Python’s standard library includes a tool to help in this domain—the
struct module knows how to both compose and parse packed binary data. In a sense,
this is another data-conversion tool that interprets strings in files as binary data.
We saw an overview of this tool in Chapter 4, but let’s take another quick look here
for more perspective. To create a packed binary data file, open it in 'wb' (write binary)
mode, and pass struct a format string and some Python objects. The format string used
here means pack as a 4-byte integer, a 4-character string (which must be a bytes string
as of Python 3.2), and a 2-byte integer, all in big-endian form (other format codes handle
padding bytes, floating-point numbers, and more):
>>> F = open('data.bin', 'wb') # Open binary output file
>>> import struct
>>> data = struct.pack('>i4sh', 7, b'spam', 8) # Make packed binary data
>>> data
b'x00x00x00x07spamx00x08'
>>> F.write(data) # Write byte string
>>> F.close()
Python creates a binary bytes data string, which we write out to the file normally—this
one consists mostly of nonprintable characters printed in hexadecimal escapes, and is
the same binary file we met earlier. To parse the values out to normal Python objects,
we simply read the string back and unpack it using the same format string. Python
extracts the values into normal Python objects—integers and a string:
>>> F = open('data.bin', 'rb')
>>> data = F.read() # Get packed binary data
>>> data
b'x00x00x00x07spamx00x08'
>>> values = struct.unpack('>i4sh', data) # Convert to Python objects
>>> values
(7, b'spam', 8)
Binary data files are advanced and somewhat low-level tools that we won’t cover in
more detail here; for more help, see the struct coverage in Chapter 37, consult the
Python library manual, or import struct and pass it to the help function interactively.
Also note that you can use the binary file-processing modes 'wb' and 'rb' to process a
simpler binary file, such as an image or audio file, as a whole without having to unpack
its contents; in such cases your code might pass it unparsed to other files or tools.
Files | 293](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-345-320.jpg)
![• Objects share operations according to their category; for instance, sequence objects
—strings, lists, and tuples—all share sequence operations such as concatenation,
length, and indexing.
• Only mutable objects—lists, dictionaries, and sets—may be changed in place; you
cannot change numbers, strings, or tuples in place.
• Files export only methods, so mutability doesn’t really apply to them—their state
may be changed when they are processed, but this isn’t quite the same as Python
core type mutability constraints.
• “Numbers” in Table 9-3 includes all number types: integer (and the distinct long
integer in 2.X), floating point, complex, decimal, and fraction.
• “Strings” in Table 9-3 includes str, as well as bytes in 3.X and unicode in 2.X; the
bytearray string type in 3.X, 2.6, and 2.7 is mutable.
• Sets are something like the keys of a valueless dictionary, but they don’t map to
values and are not ordered, so sets are neither a mapping nor a sequence type;
frozenset is an immutable variant of set.
• In addition to type category operations, as of Python 2.6 and 3.0 all the types in
Table 9-3 have callable methods, which are generally specific to their type.
Table 9-3. Object classifications
Object type Category Mutable?
Numbers (all) Numeric No
Strings (all) Sequence No
Lists Sequence Yes
Dictionaries Mapping Yes
Tuples Sequence No
Files Extension N/A
Sets Set Yes
Frozenset Set No
bytearray Sequence Yes
Why You Will Care: Operator Overloading
In Part VI of this book, we’ll see that objects we implement with classes can pick and
choose from these categories arbitrarily. For instance, if we want to provide a new kind
of specialized sequence object that is consistent with built-in sequences, we can code
a class that overloads things like indexing and concatenation:
class MySequence:
def __getitem__(self, index):
# Called on self[index], others
def __add__(self, other):
# Called on self + other
296 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-348-320.jpg)
![def __iter__(self):
# Preferred in iterations
and so on. We can also make the new object mutable or not by selectively implementing
methods called for in-place change operations (e.g., __setitem__ is called on
self[index]=value assignments). Although it’s beyond this book’s scope, it’s also pos-
sible to implement new objects in an external language like C as C extension types. For
these, we fill in C function pointer slots to choose between number, sequence, and
mapping operation sets.
Object Flexibility
This part of the book introduced a number of compound object types—collections
with components. In general:
• Lists, dictionaries, and tuples can hold any kind of object.
• Sets can contain any type of immutable object.
• Lists, dictionaries, and tuples can be arbitrarily nested.
• Lists, dictionaries, and sets can dynamically grow and shrink.
Because they support arbitrary structures, Python’s compound object types are good
at representing complex information in programs. For example, values in dictionaries
may be lists, which may contain tuples, which may contain dictionaries, and so on. The
nesting can be as deep as needed to model the data to be processed.
Let’s look at an example of nesting. The following interaction defines a tree of nested
compound sequence objects, shown in Figure 9-1. To access its components, you may
include as many index operations as required. Python evaluates the indexes from left
to right, and fetches a reference to a more deeply nested object at each step. Fig-
ure 9-1 may be a pathologically complicated data structure, but it illustrates the syntax
used to access nested objects in general:
>>> L = ['abc', [(1, 2), ([3], 4)], 5]
>>> L[1]
[(1, 2), ([3], 4)]
>>> L[1][1]
([3], 4)
>>> L[1][1][0]
[3]
>>> L[1][1][0][0]
3
References Versus Copies
Chapter 6 mentioned that assignments always store references to objects, not copies
of those objects. In practice, this is usually what you want. Because assignments can
generate multiple references to the same object, though, it’s important to be aware that
Core Types Review and Summary | 297](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-349-320.jpg)
![changing a mutable object in place may affect other references to the same object else-
where in your program. If you don’t want such behavior, you’ll need to tell Python to
copy the object explicitly.
We studied this phenomenon in Chapter 6, but it can become more subtle when larger
objects of the sort we’ve explored since then come into play. For instance, the following
example creates a list assigned to X, and another list assigned to L that embeds a refer-
ence back to list X. It also creates a dictionary D that contains another reference back to
list X:
>>> X = [1, 2, 3]
>>> L = ['a', X, 'b'] # Embed references to X's object
>>> D = {'x':X, 'y':2}
At this point, there are three references to the first list created: from the name X, from
inside the list assigned to L, and from inside the dictionary assigned to D. The situation
is illustrated in Figure 9-2.
Because lists are mutable, changing the shared list object from any of the three refer-
ences also changes what the other two reference:
>>> X[1] = 'surprise' # Changes all three references!
>>> L
['a', [1, 'surprise', 3], 'b']
>>> D
{'x': [1, 'surprise', 3], 'y': 2}
References are a higher-level analog of pointers in other languages that are always fol-
lowed when used. Although you can’t grab hold of the reference itself, it’s possible to
Figure 9-1. A nested object tree with the offsets of its components, created by running the literal
expression [‘abc’, [(1, 2), ([3], 4)], 5]. Syntactically nested objects are internally represented as
references (i.e., pointers) to separate pieces of memory.
298 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-350-320.jpg)
![store the same reference in more than one place (variables, lists, and so on). This is a
feature—you can pass a large object around a program without generating expensive
copies of it along the way. If you really do want copies, however, you can request them:
• Slice expressions with empty limits (L[:]) copy sequences.
• The dictionary, set, and list copy method (X.copy()) copies a dictionary, set, or list
(the list’s copy is new as of 3.3).
• Some built-in functions, such as list and dict make copies (list(L), dict(D),
set(S)).
• The copy standard library module makes full copies when needed.
For example, say you have a list and a dictionary, and you don’t want their values to
be changed through other variables:
>>> L = [1,2,3]
>>> D = {'a':1, 'b':2}
To prevent this, simply assign copies to the other variables, not references to the same
objects:
>>> A = L[:] # Instead of A = L (or list(L))
>>> B = D.copy() # Instead of B = D (ditto for sets)
This way, changes made from the other variables will change the copies, not the orig-
inals:
>>> A[1] = 'Ni'
>>> B['c'] = 'spam'
>>>
>>> L, D
([1, 2, 3], {'a': 1, 'b': 2})
Figure 9-2. Shared object references: because the list referenced by variable X is also referenced from
within the objects referenced by L and D, changing the shared list from X makes it look different from
L and D, too.
Core Types Review and Summary | 299](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-351-320.jpg)
![>>> A, B
([1, 'Ni', 3], {'a': 1, 'c': 'spam', 'b': 2})
In terms of our original example, you can avoid the reference side effects by slicing the
original list instead of simply naming it:
>>> X = [1, 2, 3]
>>> L = ['a', X[:], 'b'] # Embed copies of X's object
>>> D = {'x':X[:], 'y':2}
This changes the picture in Figure 9-2—L and D will now point to different lists than
X. The net effect is that changes made throughX will impact only X, not L and D; similarly,
changes to L or D will not impact X.
One final note on copies: empty-limit slices and the dictionary copy method only make
top-level copies; that is, they do not copy nested data structures, if any are present. If
you need a complete, fully independent copy of a deeply nested data structure (like the
various record structures we’ve coded in recent chapters), use the standard copy mod-
ule, introduced in Chapter 6:
import copy
X = copy.deepcopy(Y) # Fully copy an arbitrarily nested object Y
This call recursively traverses objects to copy all their parts. This is a much more rare
case, though, which is why you have to say more to use this scheme. References are
usually what you will want; when they are not, slices and copy methods are usually as
much copying as you’ll need to do.
Comparisons, Equality, and Truth
All Python objects also respond to comparisons: tests for equality, relative magnitude,
and so on. Python comparisons always inspect all parts of compound objects until a
resultcanbedetermined.Infact,whennestedobjectsarepresent,Pythonautomatically
traverses data structures to apply comparisons from left to right, and as deeply as
needed. The first difference found along the way determines the comparison result.
This is sometimes called a recursive comparison—the same comparison requested on
the top-level objects is applied to each of the nested objects, and to each of their nested
objects, and so on, until a result is found. Later in this book—in Chapter 19—we’ll see
how to write recursive functions of our own that work similarly on nested structures.
For now, think about comparing all the linked pages at two websites if you want a
metaphor for such structures, and a reason for writing recursive functions to process
them.
In terms of core types, the recursion is automatic. For instance, a comparison of list
objects compares all their components automatically until a mismatch is found or the
end is reached:
>>> L1 = [1, ('a', 3)] # Same value, unique objects
>>> L2 = [1, ('a', 3)]
300 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-352-320.jpg)
![>>> L1 == L2, L1 is L2 # Equivalent? Same object?
(True, False)
Here, L1 and L2 are assigned lists that are equivalent but distinct objects. As a review
of what we saw in Chapter 6, because of the nature of Python references, there are two
ways to test for equality:
• The == operator tests value equivalence. Python performs an equivalence test,
comparing all nested objects recursively.
• The is operator tests object identity. Python tests whether the two are really the
same object (i.e., live at the same address in memory).
In the preceding example, L1 and L2 pass the == test (they have equivalent values because
all their components are equivalent) but fail the is check (they reference two different
objects, and hence two different pieces of memory). Notice what happens for short
strings, though:
>>> S1 = 'spam'
>>> S2 = 'spam'
>>> S1 == S2, S1 is S2
(True, True)
Here, we should again have two distinct objects that happen to have the same value:
== should be true, and is should be false. But because Python internally caches and
reuses some strings as an optimization, there really is just a single string 'spam' in
memory, shared by S1 and S2; hence, the is identity test reports a true result. To trigger
the normal behavior, we need to use longer strings:
>>> S1 = 'a longer string'
>>> S2 = 'a longer string'
>>> S1 == S2, S1 is S2
(True, False)
Of course, because strings are immutable, the object caching mechanism is irrelevant
to your code—strings can’t be changed in place, regardless of how many variables refer
to them. If identity tests seem confusing, see Chapter 6 for a refresher on object refer-
ence concepts.
As a rule of thumb, the == operator is what you will want to use for almost all equality
checks; is is reserved for highly specialized roles. We’ll see cases later in the book where
both operators are put to use.
Relative magnitude comparisons are also applied recursively to nested data structures:
>>> L1 = [1, ('a', 3)]
>>> L2 = [1, ('a', 2)]
>>> L1 < L2, L1 == L2, L1 > L2 # Less, equal, greater: tuple of results
(False, False, True)
Here, L1 is greater than L2 because the nested 3 is greater than 2. By now you should
know that the result of the last line is really a tuple of three objects—the results of the
three expressions typed (an example of a tuple without its enclosing parentheses).
Core Types Review and Summary | 301](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-353-320.jpg)
![More specifically, Python compares types as follows:
• Numbers are compared by relative magnitude, after conversion to the common
highest type if needed.
• Strings are compared lexicographically (by the character set code point values re-
turned by ord), and character by character until the end or first mismatch ("abc"
< "ac").
• Lists and tuples are compared by comparing each component from left to right,
and recursively for nested structures, until the end or first mismatch ([2] > [1, 2]).
• Sets are equal if both contain the same items (formally, if each is a subset of the
other), and set relative magnitude comparisons apply subset and superset tests.
• Dictionaries compare as equal if their sorted (key, value) lists are equal. Relative
magnitude comparisons are not supported for dictionaries in Python 3.X, but they
work in 2.X as though comparing sorted (key, value) lists.
• Nonnumeric mixed-type magnitude comparisons (e.g., 1 < 'spam') are errors in
Python 3.X. They are allowed in Python 2.X, but use a fixed but arbitrary ordering
rule based on type name string. By proxy, this also applies to sorts, which use
comparisons internally: nonnumeric mixed-type collections cannot be sorted in
3.X.
In general, comparisons of structured objects proceed as though you had written the
objects as literals and compared all their parts one at a time from left to right. In later
chapters, we’ll see other object types that can change the way they get compared.
Python 2.X and 3.X mixed-type comparisons and sorts
Per the last point in the preceding section’s list, the change in Python 3.X for nonnu-
meric mixed-type comparisons applies to magnitude tests, not equality, but it also ap-
plies by proxy to sorting, which does magnitude testing internally. In Python 2.X these
all work, though mixed types compare by an arbitrary ordering:
c:code> c:python27python
>>> 11 == '11' # Equality does not convert non-numbers
False
>>> 11 >= '11' # 2.X compares by type name string: int, str
False
>>> ['11', '22'].sort() # Ditto for sorts
>>> [11, '11'].sort()
But Python 3.X disallows mixed-type magnitude testing, except numeric types and
manually converted types:
c:code> c:python33python
>>> 11 == '11' # 3.X: equality works but magnitude does not
False
>>> 11 >= '11'
TypeError: unorderable types: int() > str()
302 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-354-320.jpg)
![>>> ['11', '22'].sort() # Ditto for sorts
>>> [11, '11'].sort()
TypeError: unorderable types: str() < int()
>>> 11 > 9.123 # Mixed numbers convert to highest type
True
>>> str(11) >= '11', 11 >= int('11') # Manual conversions force the issue
(True, True)
Python 2.X and 3.X dictionary comparisons
The second-to-last point in the preceding section also merits illustration. In Python
2.X, dictionaries support magnitude comparisons, as though you were comparing sor-
ted key/value lists:
C:code> c:python27python
>>> D1 = {'a':1, 'b':2}
>>> D2 = {'a':1, 'b':3}
>>> D1 == D2 # Dictionary equality: 2.X + 3.X
False
>>> D1 < D2 # Dictionary magnitude: 2.X only
True
As noted briefly in Chapter 8, though, magnitude comparisons for dictionaries are
removed in Python 3.X because they incur too much overhead when equality is desired
(equality uses an optimized scheme in 3.X that doesn’t literally compare sorted key/
value lists):
C:code> c:python33python
>>> D1 = {'a':1, 'b':2}
>>> D2 = {'a':1, 'b':3}
>>> D1 == D2
False
>>> D1 < D2
TypeError: unorderable types: dict() < dict()
The alternative in 3.X is to either write loops to compare values by key, or compare the
sorted key/value lists manually—the items dictionary methods and sorted built-in suf-
fice:
>>> list(D1.items())
[('b', 2), ('a', 1)]
>>> sorted(D1.items())
[('a', 1), ('b', 2)]
>>>
>>> sorted(D1.items()) < sorted(D2.items()) # Magnitude test in 3.X
True
>>> sorted(D1.items()) > sorted(D2.items())
False
This takes more code, but in practice, most programs requiring this behavior will de-
velop more efficient ways to compare data in dictionaries than either this workaround
or the original behavior in Python 2.X.
Core Types Review and Summary | 303](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-355-320.jpg)
![The Meaning of True and False in Python
Notice that the test results returned in the last two examples represent true and false
values. They print as the words True and False, but now that we’re using logical tests
like these in earnest, I should be a bit more formal about what these names really mean.
In Python, as in most programming languages, an integer 0 represents false, and an
integer 1 represents true. In addition, though, Python recognizes any empty data struc-
ture as false and any nonempty data structure as true. More generally, the notions of
true and false are intrinsic properties of every object in Python—each object is either
true or false, as follows:
• Numbers are false if zero, and true otherwise.
• Other objects are false if empty, and true otherwise.
Table 9-4 gives examples of true and false values of objects in Python.
Table 9-4. Example object truth values
Object Value
"spam" True
"" False
[1, 2] True
[] False
{'a': 1} True
{} False
1 True
0.0 False
None False
As one application, because objects are true or false themselves, it’s common to see
Python programmers code tests like if X:, which, assuming X is a string, is the same
as if X != '':. In other words, you can test the object itself to see if it contains anything,
instead of comparing it to an empty, and therefore false, object of the same type (more
on if statements in the next chapter).
The None object
As shown in the last row in Table 9-4, Python also provides a special object called
None, which is always considered to be false. None was introduced briefly in Chap-
ter 4; it is the only value of a special data type in Python and typically serves as an empty
placeholder (much like a NULL pointer in C).
For example, recall that for lists you cannot assign to an offset unless that offset already
exists—the list does not magically grow if you attempt an out-of-bounds assignment.
304 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-356-320.jpg)
![To preallocate a 100-item list such that you can add to any of the 100 offsets, you can
fill it with None objects:
>>> L = [None] * 100
>>>
>>> L
[None, None, None, None, None, None, None, ... ]
This doesn’t limit the size of the list (it can still grow and shrink later), but simply
presets an initial size to allow for future index assignments. You could initialize a list
with zeros the same way, of course, but best practice dictates using None if the type of
the list’s contents is variable or not yet known.
Keep in mind that None does not mean “undefined.” That is, None is something, not
nothing (despite its name!)—it is a real object and a real piece of memory that is created
and given a built-in name by Python itself. Watch for other uses of this special object
later in the book; as we’ll learn in Part IV, it is also the default return value of functions
that don’t exit by running into a return statement with a result value.
The bool type
While we’re on the topic of truth, also keep in mind that the Python Boolean type
bool, introduced in Chapter 5, simply augments the notions of true and false in Python.
As we learned in Chapter 5, the built-in words True and False are just customized
versions of the integers 1 and 0—it’s as if these two words have been preassigned to 1
and 0 everywhere in Python. Because of the way this new type is implemented, this is
really just a minor extension to the notions of true and false already described, designed
to make truth values more explicit:
• When used explicitly in truth test code, the words True and False are equivalent
to 1 and 0, but they make the programmer’s intent clearer.
• Results of Boolean tests run interactively print as the words True and False, instead
of as 1 and 0, to make the type of result clearer.
You are not required to use only Boolean types in logical statements such as if; all
objects are still inherently true or false, and all the Boolean concepts mentioned in this
chapter still work as described if you use other types. Python also provides a bool built-
in function that can be used to test the Boolean value of an object if you want to make
this explicit (i.e., whether it is true—that is, nonzero or nonempty):
>>> bool(1)
True
>>> bool('spam')
True
>>> bool({})
False
In practice, though, you’ll rarely notice the Boolean type produced by logic tests, be-
cause Boolean results are used automatically by if statements and other selection tools.
We’ll explore Booleans further when we study logical statements in Chapter 12.
Core Types Review and Summary | 305](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-357-320.jpg)
![Python’s Type Hierarchies
As a summary and reference, Figure 9-3 sketches all the built-in object types available
in Python and their relationships. We’ve looked at the most prominent of these; most
of the other kinds of objects in Figure 9-3 correspond to program units (e.g., functions
and modules) or exposed interpreter internals (e.g., stack frames and compiled code).
The largest point to notice here is that everything in a Python system is an object type
and may be processed by your Python programs. For instance, you can pass a class to
a function, assign it to a variable, stuff it in a list or dictionary, and so on.
Type Objects
In fact, even types themselves are an object type in Python: the type of an object is an
object of type type (say that three times fast!). Seriously, a call to the built-in function
type(X) returns the type object of object X. The practical application of this is that type
objects can be used for manual type comparisons in Python if statements. However,
for reasons introduced in Chapter 4, manual type testing is usually not the right thing
to do in Python, since it limits your code’s flexibility.
One note on type names: as of Python 2.2, each core type has a new built-in name
added to support type customization through object-oriented subclassing: dict, list,
str, tuple, int, float, complex, bytes, type, set, and more. In Python 3.X names all
references classes, and in Python 2.X but not 3.X, file is also a type name and a syn-
onym for open. Calls to these names are really object constructor calls, not simply con-
version functions, though you can treat them as simple functions for basic usage.
In addition, the types standard library module in Python 3.X provides additional type
names for types that are not available as built-ins (e.g., the type of a function; in Python
2.X but not 3.X, this module also includes synonyms for built-in type names), and it is
possible to do type tests with the isinstance function. For example, all of the following
type tests are true:
type([1]) == type([]) # Compare to type of another list
type([1]) == list # Compare to list type name
isinstance([1], list) # Test if list or customization thereof
import types # types has names for other types
def f(): pass
type(f) == types.FunctionType
Because types can be subclassed in Python today, the isinstance technique is generally
recommended. See Chapter 32 for more on subclassing built-in types in Python 2.2
and later.
306 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-358-320.jpg)
![Also in Chapter 32, we will explore how type(X) and type testing in
general apply to instances of user-defined classes. In short, in Python
3.X and for new-style classes in Python 2.X, the type of a class instance
is the class from which the instance was made. For classic classes in
Python 2.X, all class instances are instead of the type “instance,” and
we must compare instance __class__ attributes to compare their types
meaningfully. Since we’re not yet equipped to tackle the subject of
classes, we’ll postpone the rest of this story until Chapter 32.
Other Types in Python
Besides the core objects studied in this part of the book, and the program-unit objects
such as functions, modules, and classes that we’ll meet later, a typical Python instal-
lation has dozens of additional object types available as linked-in C extensions or
Python classes—regular expression objects, DBM files, GUI widgets, network sockets,
and so on. Depending on whom you ask, the named tuple we met earlier in this chapter
may fall in this category too (Decimal and Fraction of Chapter 5 tend to be more am-
biguous).
The main difference between these extra tools and the built-in types we’ve seen so far
is that the built-ins provide special language creation syntax for their objects (e.g., 4 for
an integer, [1,2] for a list, the open function for files, and def and lambda for functions).
Other tools are generally made available in standard library modules that you must first
import to use, and aren’t usually considered core types. For instance, to make a regular
expression object, you import re and call re.compile(). See Python’s library reference
for a comprehensive guide to all the tools available to Python programs.
Built-in Type Gotchas
That’s the end of our look at core data types. We’ll wrap up this part of the book with
a discussion of common problems that seem to trap new users (and the occasional
expert), along with their solutions. Some of this is a review of ideas we’ve already cov-
ered, but these issues are important enough to warn about again here.
Assignment Creates References, Not Copies
Because this is such a central concept, I’ll mention it again: shared references to mutable
objects in your program can matter. For instance, in the following example, the list
object assigned to the name L is referenced both from L and from inside the list assigned
to the name M. Changing L in place changes what M references, too:
>>> L = [1, 2, 3]
>>> M = ['X', L, 'Y'] # Embed a reference to L
>>> M
['X', [1, 2, 3], 'Y']
308 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-360-320.jpg)
![>>> L[1] = 0 # Changes M too
>>> M
['X', [1, 0, 3], 'Y']
This effect usually becomes important only in larger programs, and shared references
are often exactly what you want. If objects change out from under you in unwanted
ways, you can avoid sharing objects by copying them explicitly. For lists, you can always
make a top-level copy by using an empty-limits slice, among other techniques described
earlier:
>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y'] # Embed a copy of L (or list(L), or L.copy())
>>> L[1] = 0 # Changes only L, not M
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']
Remember, slice limits default to 0 and the length of the sequence being sliced; if both
are omitted, the slice extracts every item in the sequence and so makes a top-level copy
(a new, unshared object).
Repetition Adds One Level Deep
Repeating a sequence is like adding it to itself a number of times. However, when
mutable sequences are nested, the effect might not always be what you expect. For
instance, in the following example X is assigned to L repeated four times, whereas Y is
assigned to a list containing L repeated four times:
>>> L = [4, 5, 6]
>>> X = L * 4 # Like [4, 5, 6] + [4, 5, 6] + ...
>>> Y = [L] * 4 # [L] + [L] + ... = [L, L,...]
>>> X
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y
[[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
Because L was nested in the second repetition, Y winds up embedding references back
to the original list assigned to L, and so is open to the same sorts of side effects noted
in the preceding section:
>>> L[1] = 0 # Impacts Y but not X
>>> X
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y
[[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]]
This may seem artificial and academic—until it happens unexpectedly in your code!
The same solutions to this problem apply here as in the previous section, as this is really
just another way to create the shared mutable object reference case—make copies when
you don’t want shared references:
Built-in Type Gotchas | 309](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-361-320.jpg)
![>>> L = [4, 5, 6]
>>> Y = [list(L)] * 4 # Embed a (shared) copy of L
>>> L[1] = 0
>>> Y
[[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
Even more subtly, although Y doesn’t share an object with L anymore, it still embeds
four references to the same copy of it. If you must avoid that sharing too, you’ll want
to make sure each embedded copy is unique:
>>> Y[0][1] = 99 # All four copies are still the same
>>> Y
[[4, 99, 6], [4, 99, 6], [4, 99, 6], [4, 99, 6]]
>>> L = [4, 5, 6]
>>> Y = [list(L) for i in range(4)]
>>> Y
[[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
>>> Y[0][1] = 99
>>> Y
[[4, 99, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
If you remember that repetition, concatenation, and slicing copy only the top level of
their operand objects, these sorts of cases make much more sense.
Beware of Cyclic Data Structures
We actually encountered this concept in a prior exercise: if a collection object contains
a reference to itself, it’s called a cyclic object. Python prints a [...] whenever it detects
a cycle in the object, rather than getting stuck in an infinite loop (as it once did long ago):
>>> L = ['grail'] # Append reference to same object
>>> L.append(L) # Generates cycle in object: [...]
>>> L
['grail', [...]]
Besides understanding that the three dots in square brackets represent a cycle in the
object, this case is worth knowing about because it can lead to gotchas—cyclic struc-
tures may cause code of your own to fall into unexpected loops if you don’t anticipate
them.
For instance, some programs that walk through structured data must keep a list, dic-
tionary, or set of already visited items, and check it when they’re about to step into a
cycle that could cause an unwanted loop. See the solutions to the “Test Your Knowl-
edge: Part I Exercises” on page 87 in Appendix D for more on this problem. Also watch
for general discussion of recursion in Chapter 19, as well as the reloadall.py program
in Chapter 25 and the ListTree class in Chapter 31, for concrete examples of programs
where cycle detection can matter.
The solution is knowledge: don’t use cyclic references unless you really need to, and
make sure you anticipate them in programs that must care. There are good reasons to
310 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-362-320.jpg)
![create cycles, but unless you have code that knows how to handle them, objects that
reference themselves may be more surprise than asset.
Immutable Types Can’t Be Changed in Place
And once more for completeness: you can’t change an immutable object in place. In-
stead, you construct a new object with slicing, concatenation, and so on, and assign it
back to the original reference, if needed:
T = (1, 2, 3)
T[2] = 4 # Error!
T = T[:2] + (4,) # OK: (1, 2, 4)
That might seem like extra coding work, but the upside is that the previous gotchas in
this section can’t happen when you’re using immutable objects such as tuples and
strings; because they can’t be changed in place, they are not open to the sorts of side
effects that lists are.
Chapter Summary
This chapter explored the last two major core object types—the tuple and the file. We
learned that tuples support all the usual sequence operations, have just a few methods,
do not allow any in-place changes because they are immutable, and are extended by
the named tuple type. We also learned that files are returned by the built-in open func-
tion and provide methods for reading and writing data.
Along the way we explored how to translate Python objects to and from strings for
storing in files, and we looked at the pickle, json, and struct modules for advanced
roles (object serialization and binary data). Finally, we wrapped up by reviewing some
properties common to all object types (e.g., shared references) and went through a list
of common mistakes (“gotchas”) in the object type domain.
In the next part of this book, we’ll shift gears, turning to the topic of statement syntax—
the way you code processing logic in your scripts. Along the way, this next part explores
all of Python’s basic procedural statements. The next chapter kicks off this topic with
an introduction to Python’s general syntax model, which is applicable to all statement
types. Before moving on, though, take the chapter quiz, and then work through the
end-of-part lab exercises to review type concepts. Statements largely just create and
process objects, so make sure you’ve mastered this domain by working through all the
exercises before reading on.
Test Your Knowledge: Quiz
1. How can you determine how large a tuple is? Why is this tool located where it is?
Test Your Knowledge: Quiz | 311](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-363-320.jpg)
![2. Write an expression that changes the first item in a tuple. (4, 5, 6) should become
(1, 5, 6) in the process.
3. What is the default for the processing mode argument in a file open call?
4. What module might you use to store Python objects in a file without converting
them to strings yourself?
5. How might you go about copying all parts of a nested structure at once?
6. When does Python consider an object true?
7. What is your quest?
Test Your Knowledge: Answers
1. The built-in len function returns the length (number of contained items) for any
container object in Python, including tuples. It is a built-in function instead of a
type method because it applies to many different types of objects. In general, built-
in functions and expressions may span many object types; methods are specific to
a single object type, though some may be available on more than one type (index,
for example, works on lists and tuples).
2. Because they are immutable, you can’t really change tuples in place, but you can
generate a new tuple with the desired value. Given T = (4, 5, 6), you can change
the first item by making a new tuple from its parts by slicing and concatenating: T
= (1,) + T[1:]. (Recall that single-item tuples require a trailing comma.) You could
also convert the tuple to a list, change it in place, and convert it back to a tuple,
but this is more expensive and is rarely required in practice—simply use a list if
you know that the object will require in-place changes.
3. The default for the processing mode argument in a file open call is 'r', for reading
text input. For input text files, simply pass in the external file’s name.
4. The pickle module can be used to store Python objects in a file without explicitly
converting them to strings. The struct module is related, but it assumes the data
is to be in packed binary format in the file; json similarly converts a limited set of
Python objects to and from strings per the JSON format.
5. Import the copy module, and call copy.deepcopy(X) if you need to copy all parts of
a nested structure X. This is also rarely seen in practice; references are usually the
desired behavior, and shallow copies (e.g., aList[:], aDict.copy(), set(aSet))
usually suffice for most copies.
6. An object is considered true if it is either a nonzero number or a nonempty collec-
tion object. The built-in words True and False are essentially predefined to have
the same meanings as integer 1 and 0, respectively.
7. Acceptable answers include “To learn Python,” “To move on to the next part of
the book,” or “To seek the Holy Grail.”
312 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-364-320.jpg)
![Test Your Knowledge: Part II Exercises
This session asks you to get your feet wet with built-in object fundamentals. As before,
a few new ideas may pop up along the way, so be sure to flip to the answers in Appen-
dix D when you’re done (or even when you’re not). If you have limited time, I suggest
starting with exercises 10 and 11 (the most practical of the bunch), and then working
from first to last as time allows. This is all fundamental material, so try to do as many
of these as you can; programming is a hands-on activity, and there is no substitute for
practicing what you’ve read to make ideas gel.
1. The basics. Experiment interactively with the common type operations found in
the various operation tables in this part of the book. To get started, bring up the
Python interactive interpreter, type each of the following expressions, and try to
explain what’s happening in each case. Note that the semicolon in some of these
is being used as a statement separator, to squeeze multiple statements onto a single
line: for example, X=1;X assigns and then prints a variable (more on statement
syntax in the next part of the book). Also remember that a comma between ex-
pressions usually builds a tuple, even if there are no enclosing parentheses: X,Y,Z
is a three-item tuple, which Python prints back to you in parentheses.
2 ** 16
2 / 5, 2 / 5.0
"spam" + "eggs"
S = "ham"
"eggs " + S
S * 5
S[:0]
"green %s and %s" % ("eggs", S)
'green {0} and {1}'.format('eggs', S)
('x',)[0]
('x', 'y')[1]
L = [1,2,3] + [4,5,6]
L, L[:], L[:0], L[−2], L[−2:]
([1,2,3] + [4,5,6])[2:4]
[L[2], L[3]]
L.reverse(); L
L.sort(); L
L.index(4)
{'a':1, 'b':2}['b']
D = {'x':1, 'y':2, 'z':3}
D['w'] = 0
D['x'] + D['w']
D[(1,2,3)] = 4
list(D.keys()), list(D.values()), (1,2,3) in D
[[]], ["",[],(),{},None]
Test Your Knowledge: Part II Exercises | 313](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-365-320.jpg)
![2. Indexing and slicing. At the interactive prompt, define a list named L that contains
four strings or numbers (e.g., L=[0,1,2,3]). Then, experiment with the following
boundary cases. You may never see these cases in real programs (especially not in
the bizarre ways they appear here!), but they are intended to make you think about
the underlying model, and some may be useful in less artificial forms—slicing out
of bounds can help, for example, if a sequence is as long as you expect:
a. What happens when you try to index out of bounds (e.g., L[4])?
b. What about slicing out of bounds (e.g., L[−1000:100])?
c. Finally, how does Python handle it if you try to extract a sequence in reverse,
with the lower bound greater than the higher bound (e.g., L[3:1])? Hint: try
assigning to this slice (L[3:1]=['?']), and see where the value is put. Do you
think this may be the same phenomenon you saw when slicing out of bounds?
3. Indexing, slicing, and del. Define another list L with four items, and assign an empty
list to one of its offsets (e.g., L[2]=[]). What happens? Then, assign an empty list
to a slice (L[2:3]=[]). What happens now? Recall that slice assignment deletes the
slice and inserts the new value where it used to be.
The del statement deletes offsets, keys, attributes, and names. Use it on your list
to delete an item (e.g., del L[0]). What happens if you delete an entire slice (del
L[1:])? What happens when you assign a nonsequence to a slice (L[1:2]=1)?
4. Tuple assignment. Type the following lines:
>>> X = 'spam'
>>> Y = 'eggs'
>>> X, Y = Y, X
What do you think is happening to X and Y when you type this sequence?
5. Dictionary keys. Consider the following code fragments:
>>> D = {}
>>> D[1] = 'a'
>>> D[2] = 'b'
You’ve learned that dictionaries aren’t accessed by offsets, so what’s going on here?
Does the following shed any light on the subject? (Hint: strings, integers, and tuples
share which type category?)
>>> D[(1, 2, 3)] = 'c'
>>> D
{1: 'a', 2: 'b', (1, 2, 3): 'c'}
6. Dictionary indexing. Create a dictionary named D with three entries, for keys 'a',
'b', and 'c'. What happens if you try to index a nonexistent key (D['d'])? What
does Python do if you try to assign to a nonexistent key 'd' (e.g., D['d']='spam')?
How does this compare to out-of-bounds assignments and references for lists?
Does this sound like the rule for variable names?
7. Generic operations. Run interactive tests to answer the following questions:
314 | Chapter 9: Tuples, Files, and Everything Else](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-366-320.jpg)
![a. What happens when you try to use the + operator on different/mixed types
(e.g., string + list, list + tuple)?
b. Does + work when one of the operands is a dictionary?
c. Does the append method work for both lists and strings? How about using the
keys method on lists? (Hint: what does append assume about its subject object?)
d. Finally, what type of object do you get back when you slice or concatenate two
lists or two strings?
8. String indexing. Define a string S of four characters: S = "spam". Then type the
followingexpression:S[0][0][0][0][0].Anyclueastowhat’shappeningthistime?
(Hint: recall that a string is a collection of characters, but Python characters are
one-character strings.) Does this indexing expression still work if you apply it to a
list such as ['s', 'p', 'a', 'm']? Why?
9. Immutable types. Define a string S of four characters again: S = "spam". Write an
assignment that changes the string to "slam", using only slicing and concatenation.
Could you perform the same operation using just indexing and concatenation?
How about index assignment?
10. Nesting. Write a data structure that represents your personal information: name
(first, middle, last), age, job, address, email address, and phone number. You may
build the data structure with any combination of built-in object types you like (lists,
tuples, dictionaries, strings, numbers). Then, access the individual components of
your data structures by indexing. Do some structures make more sense than others
for this object?
11. Files. Write a script that creates a new output file called myfile.txt and writes the
string "Hello file world!" into it. Then write another script that opens my-
file.txt and reads and prints its contents. Run your two scripts from the system
command line. Does the new file show up in the directory where you ran your
scripts? What if you add a different directory path to the filename passed to open?
Note: file write methods do not add newline characters to your strings; add an
explicit n at the end of the string if you want to fully terminate the line in the file.
Test Your Knowledge: Part II Exercises | 315](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-367-320.jpg)
![Python’s Statements
Table 10-1 summarizes Python’s statement set. Each statement in Python has its own
specific purpose and its own specific syntax—the rules that define its structure—
though, as we’ll see, many share common syntax patterns, and some statements’ roles
overlap. Table 10-1 also gives examples of each statement, when coded according to
its syntax rules. In your programs, these units of code can perform actions, repeat tasks,
make choices, build larger program structures, and so on.
This part of the book deals with entries in the table from the top through break and
continue. You’ve informally been introduced to a few of the statements in Table 10-1
already; this part of the book will fill in details that were skipped earlier, introduce the
rest of Python’s procedural statement set, and cover the overall syntax model. State-
ments lower in Table 10-1 that have to do with larger program units—functions,
classes, modules, and exceptions—lead to larger programming ideas, so they will each
have a section of their own. More focused statements (like del, which deletes various
components) are covered elsewhere in the book, or in Python’s standard manuals.
Table 10-1. Python statements
Statement Role Example
Assignment Creating references a, b = 'good', 'bad'
Calls and other expressions Running functions log.write("spam, ham")
print calls Printing objects print('The Killer', joke)
if/elif/else Selecting actions if "python" in text:
print(text)
for/else Iteration for x in mylist:
print(x)
while/else General loops while X > Y:
print('hello')
pass Empty placeholder while True:
pass
break Loop exit while True:
if exittest(): break
continue Loop continue while True:
if skiptest(): continue
def Functions and methods def f(a, b, c=1, *d):
print(a+b+c+d[0])
return Functions results def f(a, b, c=1, *d):
return a+b+c+d[0]
yield Generator functions def gen(n):
for i in n: yield i*2
global Namespaces x = 'old'
def function():
global x, y; x = 'new'
nonlocal Namespaces (3.X) def outer():
x = 'old'
320 | Chapter 10: Introducing Python Statements](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-372-320.jpg)
![Statement Role Example
def function():
nonlocal x; x = 'new'
import Module access import sys
from Attribute access from sys import stdin
class Building objects class Subclass(Superclass):
staticData = []
def method(self): pass
try/except/ finally Catching exceptions try:
action()
except:
print('action error')
raise Triggering exceptions raise EndSearch(location)
assert Debugging checks assert X > Y, 'X too small'
with/as Context managers (3.X, 2.6+) with open('data') as myfile:
process(myfile)
del Deleting references del data[k]
del data[i:j]
del obj.attr
del variable
Technically, Table 10-1 reflects Python 3.X’s statements. Though sufficient as a quick
preview and reference, it’s not quite complete as is. Here are a few fine points about its
content:
• Assignment statements come in a variety of syntax flavors, described in Chap-
ter 11: basic, sequence, augmented, and more.
• print is technically neither a reserved word nor a statement in 3.X, but a built-in
function call; because it will nearly always be run as an expression statement,
though (and often on a line by itself), it’s generally thought of as a statement type.
We’ll study print operations in Chapter 11.
• yield is also an expression instead of a statement as of 2.5; like print, it’s typically
used as an expression statement and so is included in this table, but scripts occa-
sionally assign or otherwise use its result, as we’ll see in Chapter 20. As an expres-
sion, yield is also a reserved word, unlike print.
Most of this table applies to Python 2.X, too, except where it doesn’t—if you are using
Python 2.X, here are a few notes for your Python, too:
• In 2.X, nonlocal is not available; as we’ll see in Chapter 17, there are alternative
ways to achieve this statement’s writeable state-retention effect.
• In 2.X, print is a statement instead of a built-in function call, with specific syntax
covered in Chapter 11.
• In 2.X, the 3.X exec code execution built-in function is a statement, with specific
syntax; since it supports enclosing parentheses, though, you can generally use its
3.X call form in 2.X code.
Python’s Statements | 321](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-373-320.jpg)
![compound statements. In other words, you can chain together only simple statements,
like assignments, prints, and function calls. Compound statements like if tests and
while loops must still appear on lines of their own (otherwise, you could squeeze an
entire program onto one line, which probably would not make you very popular among
your coworkers!).
The other special rule for statements is essentially the inverse: you can make a single
statement span across multiple lines. To make this work, you simply have to enclose
part of your statement in a bracketed pair—parentheses (()), square brackets ([]), or
curly braces ({}). Any code enclosed in these constructs can cross multiple lines: your
statement doesn’t end until Python reaches the line containing the closing part of the
pair. For instance, to continue a list literal:
mylist = [1111,
2222,
3333]
Because the code is enclosed in a square brackets pair, Python simply drops down to
the next line until it encounters the closing bracket. The curly braces surrounding dic-
tionaries (as well as set literals and dictionary and set comprehensions in 3.X and 2.7)
allow them to span lines this way too, and parentheses handle tuples, function calls,
and expressions. The indentation of the continuation lines does not matter, though
common sense dictates that the lines should be aligned somehow for readability.
Parentheses are the catchall device—because any expression can be wrapped in them,
simply inserting a left parenthesis allows you to drop down to the next line and continue
your statement:
X = (A + B +
C + D)
This technique works with compound statements, too, by the way. Anywhere you need
to code a large expression, simply wrap it in parentheses to continue it on the next line:
if (A == 1 and
B == 2 and
C == 3):
print('spam' * 3)
An older rule also allows for continuation lines when the prior line ends in a backslash:
X = A + B +
C + D # An error-prone older alternative
This alternative technique is dated, though, and is frowned on today because it’s dif-
ficult to notice and maintain the backslashes. It’s also fairly brittle and error-prone—
there can be no spaces after the backslash, and accidentally omitting it can have unex-
pected effects if the next line is mistaken to be a new statement (in this example, “C +
D” is a valid statement by itself if it’s not indented). This rule is also another throwback
to the C language, where it is commonly used in “#define” macros; again, when in
Pythonland, do as Pythonistas do, not as C programmers do.
328 | Chapter 10: Introducing Python Statements](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-380-320.jpg)
![Version skew note: This example is coded for Python 3.X. If you are
working in Python 2.X, the code works the same, but you must use
raw_input instead of input in all of this chapter’s examples, and you can
omit the outer parentheses in print statements (though they don’t hurt).
In fact, if you study the interact.py file in the examples package, you’ll
see that it does this automatically—to support 2.X compatibility, it re-
sets input if the running Python’s major version is 2 (“input” winds up
running raw_input):
import sys
if sys.version[0] == '2': input = raw_input # 2.X compatible
In 3.X, raw_input was renamed input, and print is a built-in function
instead of a statement (more on prints in the next chapter). Python 2.X
has an input too, but it tries to evaluate the input string as though it
were Python code, which probably won’t work in this context;
eval(input()) can yield the same effect 3.X.
Doing Math on User Inputs
Our script works, but now suppose that instead of converting a text string to uppercase,
we want to do some math with numeric input—squaring it, for example, perhaps in
some misguided effort of an age-input program to tease its users. We might try state-
ments like these to achieve the desired effect:
>>> reply = '20'
>>> reply ** 2
...error text omitted...
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
This won’t quite work in our script, though, because (as discussed in the prior part of
the book) Python won’t convert object types in expressions unless they are all numeric,
and input from a user is always returned to our script as a string. We cannot raise a
string of digits to a power unless we convert it manually to an integer:
>>> int(reply) ** 2
400
Armed with this information, we can now recode our loop to perform the necessary
math. Type the following in a file to test it:
while True:
reply = input('Enter text:')
if reply == 'stop': break
print(int(reply) ** 2)
print('Bye')
This script uses a single-line if statement to exit on “stop” as before, but it also converts
inputs to perform the required math. This version also adds an exit message at the
bottom. Because the print statement in the last line is not indented as much as the
A Quick Example: Interactive Loops | 331](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-383-320.jpg)
![values for unassigned names used in your program instead of treating them as
errors, it would be much more difficult for you to spot name typos in your code.
• Some operations perform assignments implicitly. In this section we’re con-
cerned with the = statement, but assignment occurs in many contexts in Python.
For instance, we’ll see later that module imports, function and class definitions,
for loop variables, and function arguments are all implicit assignments. Because
assignment works the same everywhere it pops up, all these contexts simply bind
names to object references at runtime.
Assignment Statement Forms
Although assignment is a general and pervasive concept in Python, we are primarily
interested in assignment statements in this chapter. Table 11-1 illustrates the different
assignment statement forms in Python, and their syntax patterns.
Table 11-1. Assignment statement forms
Operation Interpretation
spam = 'Spam' Basic form
spam, ham = 'yum', 'YUM' Tuple assignment (positional)
[spam, ham] = ['yum', 'YUM'] List assignment (positional)
a, b, c, d = 'spam' Sequence assignment, generalized
a, *b = 'spam' Extended sequence unpacking (Python 3.X)
spam = ham = 'lunch' Multiple-target assignment
spams += 42 Augmented assignment (equivalent to spams = spams + 42)
The first form in Table 11-1 is by far the most common: binding a name (or data struc-
ture component) to a single object. In fact, you could get all your work done with this
basic form alone. The other table entries represent special forms that are all optional,
but that programmers often find convenient in practice:
Tuple- and list-unpacking assignments
The second and third forms in the table are related. When you code a tuple or list
on the left side of the =, Python pairs objects on the right side with targets on the
left by position and assigns them from left to right. For example, in the second line
of Table 11-1, the name spam is assigned the string 'yum', and the name ham is bound
to the string 'YUM'. In this case Python internally may make a tuple of the items on
the right, which is why this is called tuple-unpacking assignment.
Sequence assignments
In later versions of Python, tuple and list assignments were generalized into in-
stances of what we now call sequence assignment—any sequence of names can be
assigned to any sequence of values, and Python assigns the items one at a time by
position. We can even mix and match the types of the sequences involved. The
340 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-392-320.jpg)
![fourth line in Table 11-1, for example, pairs a tuple of names with a string of
characters: a is assigned 's', b is assigned 'p', and so on.
Extended sequence unpacking
In Python 3.X (only), a new form of sequence assignment allows us to be more
flexible in how we select portions of a sequence to assign. The fifth line in Ta-
ble 11-1, for example, matches a with the first character in the string on the right
and b with the rest: a is assigned 's', and b is assigned 'pam'. This provides a simpler
alternative to assigning the results of manual slicing operations.
Multiple-target assignments
The sixth line in Table 11-1 shows the multiple-target form of assignment. In this
form, Python assigns a reference to the same object (the object farthest to the right)
to all the targets on the left. In the table, the names spam and ham are both assigned
references to the same string object, 'lunch'. The effect is the same as if we had
coded ham = 'lunch' followed by spam = ham, as ham evaluates to the original string
object (i.e., not a separate copy of that object).
Augmented assignments
The last line in Table 11-1 is an example of augmented assignment—a shorthand
that combines an expression and an assignment in a concise way. Saying spam +=
42, for example, has the same effect as spam = spam + 42, but the augmented form
requires less typing and is generally quicker to run. In addition, if the subject is
mutable and supports the operation, an augmented assignment may run even
quicker by choosing an in-place update operation instead of an object copy. There
is one augmented assignment statement for every binary expression operator in
Python.
Sequence Assignments
We’ve already used and explored basic assignments in this book, so we’ll take them as
a given. Here are a few simple examples of sequence-unpacking assignments in action:
% python
>>> nudge = 1 # Basic assignment
>>> wink = 2
>>> A, B = nudge, wink # Tuple assignment
>>> A, B # Like A = nudge; B = wink
(1, 2)
>>> [C, D] = [nudge, wink] # List assignment
>>> C, D
(1, 2)
Notice that we really are coding two tuples in the third line in this interaction—we’ve
just omitted their enclosing parentheses. Python pairs the values in the tuple on the
right side of the assignment operator with the variables in the tuple on the left side and
assigns the values one at a time.
Assignment Statements | 341](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-393-320.jpg)
![Tuple assignment leads to a common coding trick in Python that was introduced in a
solution to the exercises at the end of Part II. Because Python creates a temporary tuple
that saves the original values of the variables on the right while the statement runs,
unpacking assignments are also a way to swap two variables’ values without creating
a temporary variable of your own—the tuple on the right remembers the prior values
of the variables automatically:
>>> nudge = 1
>>> wink = 2
>>> nudge, wink = wink, nudge # Tuples: swaps values
>>> nudge, wink # Like T = nudge; nudge = wink; wink = T
(2, 1)
In fact, the original tuple and list assignment forms in Python have been generalized to
accept any type of sequence (really, iterable) on the right as long as it is of the same
length as the sequence on the left. You can assign a tuple of values to a list of variables,
a string of characters to a tuple of variables, and so on. In all cases, Python assigns items
in the sequence on the right to variables in the sequence on the left by position, from
left to right:
>>> [a, b, c] = (1, 2, 3) # Assign tuple of values to list of names
>>> a, c
(1, 3)
>>> (a, b, c) = "ABC" # Assign string of characters to tuple
>>> a, c
('A', 'C')
Technically speaking, sequence assignment actually supports any iterable object on the
right, not just any sequence. This is a more general category that includes collections
both physical (e.g., lists) and virtual (e.g., a file’s lines), which was defined briefly in
Chapter 4 and has popped up in passing ever since. We’ll firm up this term when we
explore iterables in Chapter 14 and Chapter 20.
Advanced sequence assignment patterns
Althoughwecanmixandmatchsequencetypesaroundthe= symbol,wemustgenerally
have the same number of items on the right as we have variables on the left, or we’ll get
an error. Python 3.X allows us to be more general with extended unpacking * syntax,
described in the next section. But normally in 3.X—and always in 2.X—the number of
items in the assignment target and subject must match:
>>> string = 'SPAM'
>>> a, b, c, d = string # Same number on both sides
>>> a, d
('S', 'M')
>>> a, b, c = string # Error if not
...error text omitted...
ValueError: too many values to unpack (expected 3)
342 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-394-320.jpg)
![To be more flexible, we can slice in both 2.X and 3.X. There are a variety of ways to
employ slicing to make this last case work:
>>> a, b, c = string[0], string[1], string[2:] # Index and slice
>>> a, b, c
('S', 'P', 'AM')
>>> a, b, c = list(string[:2]) + [string[2:]] # Slice and concatenate
>>> a, b, c
('S', 'P', 'AM')
>>> a, b = string[:2] # Same, but simpler
>>> c = string[2:]
>>> a, b, c
('S', 'P', 'AM')
>>> (a, b), c = string[:2], string[2:] # Nested sequences
>>> a, b, c
('S', 'P', 'AM')
As the last example in this interaction demonstrates, we can even assign nested se-
quences, and Python unpacks their parts according to their shape, as expected. In this
case, we are assigning a tuple of two items, where the first item is a nested sequence (a
string), exactly as though we had coded it this way:
>>> ((a, b), c) = ('SP', 'AM') # Paired by shape and position
>>> a, b, c
('S', 'P', 'AM')
Python pairs the first string on the right ('SP') with the first tuple on the left ((a, b))
and assigns one character at a time, before assigning the entire second string ('AM') to
the variable c all at once. In this event, the sequence-nesting shape of the object on the
left must match that of the object on the right. Nested sequence assignment like this is
somewhat rare to see, but it can be convenient for picking out the parts of data struc-
tures with known shapes.
Forexample,we’llseeinChapter13thatthistechniquealsoworksinfor loops,because
loop items are assigned to the target given in the loop header:
for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: ... # Simple tuple assignment
for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: ... # Nested tuple assignment
In a note in Chapter 18, we’ll also see that this nested tuple (really, sequence) unpacking
assignment form works for function argument lists in Python 2.X (though not in 3.X),
because function arguments are passed by assignment as well:
def f(((a, b), c)): ... # For arguments too in Python 2.X, but not 3.X
f(((1, 2), 3))
Sequence-unpacking assignments also give rise to another common coding idiom in
Python—assigning an integer series to a set of variables:
Assignment Statements | 343](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-395-320.jpg)
![>>> red, green, blue = range(3)
>>> red, blue
(0, 2)
This initializes the three names to the integer codes0, 1, and 2, respectively (it’s Python’s
equivalent of the enumerated data types you may have seen in other languages). To
make sense of this, you need to know that the range built-in function generates a list
of successive integers (in 3.X only, it requires a list around it if you wish to display its
values all at once like this):
>>> list(range(3)) # list() required in Python 3.X only
[0, 1, 2]
This call was previewed briefly in Chapter 4; because range is commonly used in for
loops, we’ll say more about it in Chapter 13.
Another place you may see a tuple assignment at work is for splitting a sequence into
its front and the rest in loops like this:
>>> L = [1, 2, 3, 4]
>>> while L:
... front, L = L[0], L[1:] # See next section for 3.X * alternative
... print(front, L)
...
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []
The tuple assignment in the loop here could be coded as the following two lines instead,
but it’s often more convenient to string them together:
... front = L[0]
... L = L[1:]
Notice that this code is using the list as a sort of stack data structure, which can often
also be achieved with the append and pop methods of list objects; here, front =
L.pop(0) would have much the same effect as the tuple assignment statement, but it
would be an in-place change. We’ll learn more about while loops, and other (often
better) ways to step through a sequence with for loops, in Chapter 13.
Extended Sequence Unpacking in Python 3.X
The prior section demonstrated how to use manual slicing to make sequence assign-
ments more general. In Python 3.X (but not 2.X), sequence assignment has been gen-
eralized to make this easier. In short, a single starred name, *X, can be used in the
assignment target in order to specify a more general matching against the sequence—
the starred name is assigned a list, which collects all items in the sequence not assigned
to other names. This is especially handy for common coding patterns such as splitting
a sequence into its “front” and “rest,” as in the preceding section’s last example.
344 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-396-320.jpg)
![Extended unpacking in action
Let’s look at an example. As we’ve seen, sequence assignments normally require exactly
as many names in the target on the left as there are items in the subject on the right.
We get an error if the lengths disagree in both 2.X and 3.X (unless we manually sliced
on the right, as shown in the prior section):
C:code> c:python33python
>>> seq = [1, 2, 3, 4]
>>> a, b, c, d = seq
>>> print(a, b, c, d)
1 2 3 4
>>> a, b = seq
ValueError: too many values to unpack (expected 2)
In Python 3.X, though, we can use a single starred name in the target to match more
generally. In the following continuation of our interactive session, a matches the first
item in the sequence, and b matches the rest:
>>> a, *b = seq
>>> a
1
>>> b
[2, 3, 4]
When a starred name is used, the number of items in the target on the left need not
match the length of the subject sequence. In fact, the starred name can appear anywhere
in the target. For instance, in the next interaction b matches the last item in the se-
quence, and a matches everything before the last:
>>> *a, b = seq
>>> a
[1, 2, 3]
>>> b
4
When the starred name appears in the middle, it collects everything between the other
names listed. Thus, in the following interaction a and c are assigned the first and last
items, and b gets everything in between them:
>>> a, *b, c = seq
>>> a
1
>>> b
[2, 3]
>>> c
4
More generally, wherever the starred name shows up, it will be assigned a list that
collects every unassigned name at that position:
>>> a, b, *c = seq
>>> a
Assignment Statements | 345](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-397-320.jpg)
![1
>>> b
2
>>> c
[3, 4]
Naturally, like normal sequence assignment, extended sequence unpacking syntax
works for any sequence types (really, again, any iterable), not just lists. Here it is un-
packing characters in a string and a range (an iterable in 3.X):
>>> a, *b = 'spam'
>>> a, b
('s', ['p', 'a', 'm'])
>>> a, *b, c = 'spam'
>>> a, b, c
('s', ['p', 'a'], 'm')
>>> a, *b, c = range(4)
>>> a, b, c
(0, [1, 2], 3)
This is similar in spirit to slicing, but not exactly the same—a sequence unpacking
assignment always returns a list for multiple matched items, whereas slicing returns a
sequence of the same type as the object sliced:
>>> S = 'spam'
>>> S[0], S[1:] # Slices are type-specific, * assignment always returns a list
('s', 'pam')
>>> S[0], S[1:3], S[3]
('s', 'pa', 'm')
Given this extension in 3.X, as long as we’re processing a list the last example of the
prior section becomes even simpler, since we don’t have to manually slice to get the
first and rest of the items:
>>> L = [1, 2, 3, 4]
>>> while L:
... front, *L = L # Get first, rest without slicing
... print(front, L)
...
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []
Boundary cases
Although extended sequence unpacking is flexible, some boundary cases are worth
noting. First, the starred name may match just a single item, but is always assigned a list:
>>> seq = [1, 2, 3, 4]
346 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-398-320.jpg)
![>>> a, b, c, *d = seq
>>> print(a, b, c, d)
1 2 3 [4]
Second, if there is nothing left to match the starred name, it is assigned an empty list,
regardless of where it appears. In the following, a, b, c, and d have matched every item
in the sequence, but Python assigns e an empty list instead of treating this as an error
case:
>>> a, b, c, d, *e = seq
>>> print(a, b, c, d, e)
1 2 3 4 []
>>> a, b, *e, c, d = seq
>>> print(a, b, c, d, e)
1 2 3 4 []
Finally, errors can still be triggered if there is more than one starred name, if there are
too few values and no star (as before), and if the starred name is not itself coded inside
a sequence:
>>> a, *b, c, *d = seq
SyntaxError: two starred expressions in assignment
>>> a, b = seq
ValueError: too many values to unpack (expected 2)
>>> *a = seq
SyntaxError: starred assignment target must be in a list or tuple
>>> *a, = seq
>>> a
[1, 2, 3, 4]
A useful convenience
Keep in mind that extended sequence unpacking assignment is just a convenience. We
can usually achieve the same effects with explicit indexing and slicing (and in fact must
in Python 2.X), but extended unpacking is simpler to code. The common “first, rest”
splitting coding pattern, for example, can be coded either way, but slicing involves extra
work:
>>> seq
[1, 2, 3, 4]
>>> a, *b = seq # First, rest
>>> a, b
(1, [2, 3, 4])
>>> a, b = seq[0], seq[1:] # First, rest: traditional
>>> a, b
(1, [2, 3, 4])
Assignment Statements | 347](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-399-320.jpg)
![The also-common “rest, last” splitting pattern can similarly be coded either way, but
the new extended unpacking syntax requires noticeably fewer keystrokes:
>>> *a, b = seq # Rest, last
>>> a, b
([1, 2, 3], 4)
>>> a, b = seq[:-1], seq[-1] # Rest, last: traditional
>>> a, b
([1, 2, 3], 4)
Because it is not only simpler but, arguably, more natural, extended sequence unpack-
ing syntax will likely become widespread in Python code over time.
Application to for loops
Because the loop variable in the for loop statement can be any assignment target, ex-
tended sequence assignment works here too. We met the for loop iteration tool briefly
in Chapter 4 and will study it formally in Chapter 13. In Python 3.X, extended assign-
ments mayshow up afterthewordfor,whereasimplevariablenameismorecommonly
used:
for (a, *b, c) in [(1, 2, 3, 4), (5, 6, 7, 8)]:
...
When used in this context, on each iteration Python simply assigns the next tuple of
values to the tuple of names. On the first loop, for example, it’s as if we’d run the
following assignment statement:
a, *b, c = (1, 2, 3, 4) # b gets [2, 3]
The names a, b, and c can be used within the loop’s code to reference the extracted
components. In fact, this is really not a special case at all, but just an instance of general
assignment at work. As we saw earlier in this chapter, we can do the same thing with
simple tuple assignment in both Python 2.X and 3.X:
for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: # a, b, c = (1, 2, 3), ...
And we can always emulate 3.X’s extended assignment behavior in 2.X by manually
slicing:
for all in [(1, 2, 3, 4), (5, 6, 7, 8)]:
a, b, c = all[0], all[1:3], all[3]
Since we haven’t learned enough to get more detailed about the syntax of for loops,
we’ll return to this topic in Chapter 13.
Multiple-Target Assignments
A multiple-target assignment simply assigns all the given names to the object all the
way to the right. The following, for example, assigns the three variables a, b, and c to
the string 'spam':
348 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-400-320.jpg)
![>>> a = b = c = 'spam'
>>> a, b, c
('spam', 'spam', 'spam')
This form is equivalent to (but easier to code than) these three assignments:
>>> c = 'spam'
>>> b = c
>>> a = b
Multiple-target assignment and shared references
Keep in mind that there is just one object here, shared by all three variables (they all
wind up pointing to the same object in memory). This behavior is fine for immutable
types—for example, when initializing a set of counters to zero (recall that variables
must be assigned before they can be used in Python, so you must initialize counters to
zero before you can start adding to them):
>>> a = b = 0
>>> b = b + 1
>>> a, b
(0, 1)
Here, changing b only changes b because numbers do not support in-place changes. As
long as the object assigned is immutable, it’s irrelevant if more than one name references
it.
As usual, though, we have to be more cautious when initializing variables to an empty
mutable object such as a list or dictionary:
>>> a = b = []
>>> b.append(42)
>>> a, b
([42], [42])
This time, because a and b reference the same object, appending to it in place through
b will impact what we see through a as well. This is really just another example of the
shared reference phenomenon we first met in Chapter 6. To avoid the issue, initialize
mutable objects in separate statements instead, so that each creates a distinct empty
object by running a distinct literal expression:
>>> a = []
>>> b = [] # a and b do not share the same object
>>> b.append(42)
>>> a, b
([], [42])
A tuple assignment like the following has the same effect—by running two list expres-
sions, it creates two distinct objects:
>>> a, b = [], [] # a and b do not share the same object
Assignment Statements | 349](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-401-320.jpg)
![the long form, X = X + Y, X appears twice and must be run twice. Because of this,
augmented assignments usually run faster.
• The optimal technique is automatically chosen. That is, for objects that support
in-place changes, the augmented forms automatically perform in-place change op-
erations instead of slower copies.
The last point here requires a bit more explanation. For augmented assignments, in-
place operations may be applied for mutable objects as an optimization. Recall that
lists can be extended in a variety of ways. To add a single item to the end of a list, we
can concatenate or call append:
>>> L = [1, 2]
>>> L = L + [3] # Concatenate: slower
>>> L
[1, 2, 3]
>>> L.append(4) # Faster, but in place
>>> L
[1, 2, 3, 4]
And to add a set of items to the end, we can either concatenate again or call the list
extend method:2
>>> L = L + [5, 6] # Concatenate: slower
>>> L
[1, 2, 3, 4, 5, 6]
>>> L.extend([7, 8]) # Faster, but in place
>>> L
[1, 2, 3, 4, 5, 6, 7, 8]
In both cases, concatenation is less prone to the side effects of shared object references
but will generally run slower than the in-place equivalent. Concatenation operations
must create a new object, copy in the list on the left, and then copy in the list on the
right. By contrast, in-place method calls simply add items at the end of a memory block
(it can be a bit more complicated than that internally, but this description suffices).
When we use augmented assignment to extend a list, we can largely forget these details
—Python automatically calls the quicker extend method instead of using the slower
concatenation operation implied by +:
>>> L += [9, 10] # Mapped to L.extend([9, 10])
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Note however, that because of this equivalence += for a list is not exactly the same as a
+ and = in all cases—for lists += allows arbitrary sequences (just like extend), but con-
catenation normally does not:
>>> L = []
>>> L += 'spam' # += and extend allow any sequence, but + does not!
2. As suggested in Chapter 6, we can also use slice assignment (e.g., L[len(L):] = [11,12,13]), but this
works roughly the same as the simpler and more mnemonic list extend method.
Assignment Statements | 351](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-403-320.jpg)
![>>> L
['s', 'p', 'a', 'm']
>>> L = L + 'spam'
TypeError: can only concatenate list (not "str") to list
Augmented assignment and shared references
This behavior is usually what we want, but notice that it implies that the += is an in-
place change for lists; thus, it is not exactly like + concatenation, which always makes
a new object. As for all shared reference cases, this difference might matter if other
names reference the object being changed:
>>> L = [1, 2]
>>> M = L # L and M reference the same object
>>> L = L + [3, 4] # Concatenation makes a new object
>>> L, M # Changes L but not M
([1, 2, 3, 4], [1, 2])
>>> L = [1, 2]
>>> M = L
>>> L += [3, 4] # But += really means extend
>>> L, M # M sees the in-place change too!
([1, 2, 3, 4], [1, 2, 3, 4])
This only matters for mutables like lists and dictionaries, and it is a fairly obscure case
(at least, until it impacts your code!). As always, make copies of your mutable objects
if you need to break the shared reference structure.
Variable Name Rules
Now that we’ve explored assignment statements, it’s time to get more formal about the
use of variable names. In Python, names come into existence when you assign values
to them, but there are a few rules to follow when choosing names for the subjects of
your programs:
Syntax: (underscore or letter) + (any number of letters, digits, or underscores)
Variable names must start with an underscore or letter, which can be followed by
any number of letters, digits, or underscores. _spam, spam, and Spam_1 are legal
names, but 1_Spam, spam$, and @#! are not.
Case matters: SPAM is not the same as spam
Python always pays attention to case in programs, both in names you create and
in reserved words. For instance, the names X and x refer to two different variables.
For portability, case also matters in the names of imported module files, even on
platforms where the filesystems are case-insensitive. That way, your imports still
work after programs are copied to differing platforms.
Reserved words are off-limits
Names you define cannot be the same as words that mean special things in the
Python language. For instance, if you try to use a variable name like class, Python
352 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-404-320.jpg)
![• Names that begin with two underscores and do not end with two more (__X) are
localized (“mangled”) to enclosing classes (see the discussion of pseudoprivate
attributes in Chapter 31).
• The name that is just a single underscore (_) retains the result of the last expression
when you are working interactively.
In addition to these Python interpreter conventions, there are various other conventions
that Python programmers usually follow. For instance, later in the book we’ll see that
class names commonly start with an uppercase letter and module names with a low-
ercase letter, and that the name self, though not reserved, usually has a special role in
classes. In Chapter 17 we’ll also study another, larger category of names known as the
built-ins, which are predefined but not reserved (and so can be reassigned: open = 42
works, though sometimes you might wish it didn’t!).
Names have no type, but objects do
This is mostly review, but remember that it’s crucial to keep Python’s distinction be-
tween names and objects clear. As described in Chapter 6, objects have a type (e.g.,
integer, list) and may be mutable or not. Names (a.k.a. variables), on the other hand,
are always just references to objects; they have no notion of mutability and have no
associated type information, apart from the type of the object they happen to reference
at a given point in time.
Thus, it’s OK to assign the same name to different kinds of objects at different times:
>>> x = 0 # x bound to an integer object
>>> x = "Hello" # Now it's a string
>>> x = [1, 2, 3] # And now it's a list
Inlaterexamples,you’llseethatthisgenericnatureofnamescanbeadecidedadvantage
in Python programming. In Chapter 17, you’ll also learn that names also live in some-
thing called a scope, which defines where they can be used; the place where you assign
a name determines where it is visible.4
For additional naming suggestions, see the discussion of naming con-
ventions in Python’s semi-official style guide, known as PEP 8. This
guide is available at http://www.python.org/dev/peps/pep-0008, or via a
web search for “Python PEP 8.” Technically, this document formalizes
coding standards for Python library code.
Though useful, the usual caveats about coding standards apply here.
Foronething,PEP8comeswithmoredetailthanyouareprobablyready
4. If you’ve used a more restrictive language like C++, you may be interested to know that there is no notion
of C++’s const declaration in Python; certain objects may be immutable, but names can always be
assigned. Python also has ways to hide names in classes and modules, but they’re not the same as C++’s
declarations (if hiding attributes matters to you, see the coverage of _X module names in Chapter 25,
__X class names in Chapter 31, and the Private and Public class decorators example in Chapter 39).
Assignment Statements | 355](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-407-320.jpg)
![Forinstance,though younormallyruna3.Xprint callon aline byitselfasanexpression
statement, it returns a value like any other function call (its return value is None, the
default return value for functions that don’t return anything meaningful):
>>> x = print('spam') # print is a function call expression in 3.X
spam
>>> print(x) # But it is coded as an expression statement
None
Also keep in mind that although expressions can appear as statements in Python, state-
ments cannot be used as expressions. A statement that is not an expression must gen-
erallyappearonalineallbyitself,notnestedinalargersyntacticstructure.Forexample,
Python doesn’t allow you to embed assignment statements (=) in other expressions.
The rationale for this is that it avoids common coding mistakes; you can’t accidentally
change a variable by typing = when you really mean to use the == equality test. You’ll
see how to code around this restriction when you meet the Python while loop in Chap-
ter 13.
Expression Statements and In-Place Changes
This brings up another mistake that is common in Python work. Expression statements
are often used to run list methods that change a list in place:
>>> L = [1, 2]
>>> L.append(3) # Append is an in-place change
>>> L
[1, 2, 3]
However, it’s not unusual for Python newcomers to code such an operation as an as-
signment statement instead, intending to assign L to the larger list:
>>> L = L.append(4) # But append returns None, not L
>>> print(L) # So we lose our list!
None
This doesn’t quite work, though. Calling an in-place change operation such as append,
sort, or reverse on a list always changes the list in place, but these methods do not
return the list they have changed; instead, they return the None object. Thus, if you
assign such an operation’s result back to the variable name, you effectively lose the list
(and it is probably garbage-collected in the process!).
The moral of the story is, don’t do this—call in-place change operations without as-
signing their results. We’ll revisit this phenomenon in the section “Common Coding
Gotchas” on page 463 because it can also appear in the context of some looping state-
ments we’ll meet in later chapters.
Expression Statements | 357](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-409-320.jpg)
![The Python 3.X print Function
Strictly speaking, printing is not a separate statement form in 3.X. Instead, it is simply
an instance of the expression statement we studied in the preceding section.
The print built-in function is normally called on a line of its own, because it doesn’t
return any value we care about (technically, it returns None, as we saw in the preceding
section). Because it is a normal function, though, printing in 3.X uses standard function-
call syntax, rather than a special statement form. And because it provides special op-
eration modes with keyword arguments, this form is both more general and supports
future enhancements better.
By comparison, Python 2.X print statements have somewhat ad hoc syntax to support
extensions such as end-of-line suppression and target files. Further, the 2.X statement
does not support separator specification at all; in 2.X, you wind up building strings
ahead of time more often than you do in 3.X. Rather than adding yet more ad hoc
syntax, Python 3.X’s print takes a single, general approach that covers them all.
Call format
Syntactically, calls to the 3.X print function have the following form (the flush argu-
ment is new as of Python 3.3):
print([object, ...][, sep=' '][, end='n'][, file=sys.stdout][, flush=False])
In this formal notation, items in square brackets are optional and may be omitted in a
given call, and values after = give argument defaults. In English, this built-in function
prints the textual representation of one or more objects separated by the string sep and
followed by the string end to the stream file, flushing buffered output or not per flush.
Thesep,end,file,and(in3.3andlater)flush parts,ifpresent,mustbegivenaskeyword
arguments—that is, you must use a special “name=value” syntax to pass the arguments
by name instead of position. Keyword arguments are covered in depth in Chapter 18,
but they’re straightforward to use. The keyword arguments sent to this call may appear
in any left-to-right order following the objects to be printed, and they control the
print operation:
• sep is a string inserted between each object’s text, which defaults to a single space
if not passed; passing an empty string suppresses separators altogether.
• end is a string added at the end of the printed text, which defaults to a n newline
character if not passed. Passing an empty string avoids dropping down to the next
output line at the end of the printed text—the next print will keep adding to the
end of the current output line.
• file specifies the file, standard stream, or other file-like object to which the text
will be sent; it defaults to the sys.stdout standard output stream if not passed. Any
object with a file-like write(string) method may be passed, but real files should
be already opened for output.
Print Operations | 359](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-411-320.jpg)
![• flush, added in 3.3, defaults to False. It allows prints to mandate that their text be
flushed through the output stream immediately to any waiting recipients. Nor-
mally, whether printed output is buffered in memory or not is determined by
file; passing a true value to flush forcibly flushes the stream.
The textual representation of each object to be printed is obtained by passing the object
to the str built-in call (or its equivalent inside Python); as we’ve seen, this built-in
returns a “user friendly” display string for any object.5 With no arguments at all, the
print function simply prints a newline character to the standard output stream, which
usually displays a blank line.
The 3.X print function in action
Printing in 3.X is probably simpler than some of its details may imply. To illustrate,
let’s run some quick examples. The following prints a variety of object types to the
default standard output stream, with the default separator and end-of-line formatting
added (these are the defaults because they are the most common use case):
C:code> c:python33python
>>> print() # Display a blank line
>>> x = 'spam'
>>> y = 99
>>> z = ['eggs']
>>>
>>> print(x, y, z) # Print three objects per defaults
spam 99 ['eggs']
There’s no need to convert objects to strings here, as would be required for file write
methods. By default, print calls add a space between the objects printed. To suppress
this, send an empty string to the sep keyword argument, or send an alternative separator
of your choosing:
>>> print(x, y, z, sep='') # Suppress separator
spam99['eggs']
>>>
>>> print(x, y, z, sep=', ') # Custom separator
spam, 99, ['eggs']
Also by default, print adds an end-of-line character to terminate the output line. You
can suppress this and avoid the line break altogether by passing an empty string to the
end keyword argument, or you can pass a different terminator of your own including a
n character to break the line manually if desired (the second of the following is two
statements on one line, separated by a semicolon):
5. Technically, printing uses the equivalent of str in the internal implementation of Python, but the effect
is the same. Besides this to-string conversion role, str is also the name of the string data type and can be
used to decode Unicode strings from raw bytes with an extra encoding argument, as we’ll learn in
Chapter 37; this latter role is an advanced usage that we can safely ignore here.
360 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-412-320.jpg)
![>>> print(x, y, z, end='') # Suppress line break
spam 99 ['eggs']>>>
>>>
>>> print(x, y, z, end=''); print(x, y, z) # Two prints, same output line
spam 99 ['eggs']spam 99 ['eggs']
>>> print(x, y, z, end='...n') # Custom line end
spam 99 ['eggs']...
>>>
You can also combine keyword arguments to specify both separators and end-of-line
strings—they may appear in any order but must appear after all the objects being
printed:
>>> print(x, y, z, sep='...', end='!n') # Multiple keywords
spam...99...['eggs']!
>>> print(x, y, z, end='!n', sep='...') # Order doesn't matter
spam...99...['eggs']!
Here is how the file keyword argument is used—it directs the printed text to an open
output file or other compatible object for the duration of the single print (this is really
a form of stream redirection, a topic we will revisit later in this section):
>>> print(x, y, z, sep='...', file=open('data.txt', 'w')) # Print to a file
>>> print(x, y, z) # Back to stdout
spam 99 ['eggs']
>>> print(open('data.txt').read()) # Display file text
spam...99...['eggs']
Finally, keep in mind that the separator and end-of-line options provided by print op-
erations are just conveniences. If you need to display more specific formatting, don’t
print this way. Instead, build up a more complex string ahead of time or within the
print itself using the string tools we met in Chapter 7, and print the string all at once:
>>> text = '%s: %-.4f, %05d' % ('Result', 3.14159, 42)
>>> print(text)
Result: 3.1416, 00042
>>> print('%s: %-.4f, %05d' % ('Result', 3.14159, 42))
Result: 3.1416, 00042
As we’ll see in the next section, almost everything we’ve just seen about the 3.X
print function also applies directly to 2.X print statements—which makes sense, given
that the function was intended to both emulate and improve upon 2.X printingsupport.
The Python 2.X print Statement
As mentioned earlier, printing in Python 2.X uses a statement with unique and specific
syntax, rather than a built-in function. In practice, though, 2.X printing is mostly a
variation on a theme; with the exception of separator strings (which are supported in
3.X but not 2.X) and flushes on prints (available as of 3.3 only), everything we can do
with the 3.X print function has a direct translation to the 2.X print statement.
Print Operations | 361](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-413-320.jpg)
![In the next chapter, we’ll continue our statement tour by filling in details about the
if statement, Python’s main selection tool; there, we’ll also revisit Python’s syntax
model in more depth and look at the behavior of Boolean expressions. Before we move
on, though, the end-of-chapter quiz will test your knowledge of what you’ve learned
here.
Test Your Knowledge: Quiz
1. Name three ways that you can assign three variables to the same value.
2. Why might you need to care when assigning three variables to a mutable object?
3. What’s wrong with saying L = L.sort()?
4. How might you use the print operation to send text to an external file?
Test Your Knowledge: Answers
1. You can use multiple-target assignments (A = B = C = 0), sequence assignment
(A, B, C = 0, 0, 0), or multiple assignment statements on three separate lines (A
= 0, B = 0, and C = 0). With the latter technique, as introduced in Chapter 10, you
can also string the three separate statements together on the same line by separating
them with semicolons (A = 0; B = 0; C = 0).
2. If you assign them this way:
A = B = C = []
all three names reference the same object, so changing it in place from one (e.g.,
A.append(99)) will affect the others. This is true only for in-place changes to mu-
table objects like lists and dictionaries; for immutable objects such as numbers and
strings, this issue is irrelevant.
3. The list sort method is like append in that it makes an in-place change to the subject
list—it returns None, not the list it changes. The assignment back to L sets L to
None, not to the sorted list. As discussed both earlier and later in this book (e.g.,
Chapter 8), a newer built-in function, sorted, sorts any sequence and returns a new
list with the sorting result; because this is not an in-place change, its result can be
meaningfully assigned to a name.
4. To print to a file for a single print operation, you can use 3.X’s print(X, file=F)
call form, use 2.X’s extended print >> file, X statement form, or assign
sys.stdout to a manually opened file before the print and restore the original after.
You can also redirect all of a program’s printed text to a file with special syntax in
the system shell, but this is outside Python’s scope.
370 | Chapter 11: Assignments, Expressions, and Prints](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-422-320.jpg)
![If you’ve used languages like C or Pascal, you might be interested to know that there
is no switch or case statement in Python that selects an action based on a variable’s
value. Instead, you usually code multiway branching as a series of if/elif tests, as in
the prior example, and occasionally by indexing dictionaries or searching lists. Because
dictionaries and lists can be built at runtime dynamically, they are sometimes more
flexible than hardcoded if logic in your script:
>>> choice = 'ham'
>>> print({'spam': 1.25, # A dictionary-based 'switch'
... 'ham': 1.99, # Use has_key or get for default
... 'eggs': 0.99,
... 'bacon': 1.10}[choice])
1.99
Although it may take a few moments for this to sink in the first time you see it, this
dictionary is a multiway branch—indexing on the key choice branches to one of a set
of values, much like a switch in C. An almost equivalent but more verbose Python if
statement might look like the following:
>>> if choice == 'spam': # The equivalent if statement
... print(1.25)
... elif choice == 'ham':
... print(1.99)
... elif choice == 'eggs':
... print(0.99)
... elif choice == 'bacon':
... print(1.10)
... else:
... print('Bad choice')
...
1.99
Though it’s perhaps more readable, the potential downside of an if like this is that,
short of constructing it as a string and running it with tools like the prior chapter’s
eval or exec, you cannot construct it at runtime as easily as a dictionary. In more dy-
namic programs, data structures offer added flexibility.
Handling switch defaults
Notice the else clause on the if here to handle the default case when no key matches.
As we saw in Chapter 8, dictionary defaults can be coded with in expressions, get
method calls, or exception catching with the try statement introduced in the preceding
chapter. All of the same techniques can be used here to code a default action in a
dictionary-based multiway branch. As a review in the context of this use case, here’s
the get scheme at work with defaults:
>>> branch = {'spam': 1.25,
... 'ham': 1.99,
... 'eggs': 0.99}
>>> print(branch.get('spam', 'Bad choice'))
1.25
if Statements | 373](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-425-320.jpg)
![>>> print(branch.get('bacon', 'Bad choice'))
Bad choice
An in membership test in an if statement can have the same default effect:
>>> choice = 'bacon'
>>> if choice in branch:
... print(branch[choice])
... else:
... print('Bad choice')
...
Bad choice
And the try statement is a general way to handle defaults by catching and handling the
exceptions they’d otherwise trigger (for more on exceptions, see Chapter 11’s overview
and Part VII’s full treatment):
>>> try:
... print(branch[choice])
... except KeyError:
... print('Bad choice')
...
Bad choice
Handling larger actions
Dictionaries are good for associating values with keys, but what about the more com-
plicated actions you can code in the statement blocks associated with if statements?
In Part IV, you’ll learn that dictionaries can also contain functions to represent more
complex branch actions and implement general jump tables. Such functions appear as
dictionary values, they may be coded as function names or inline lambdas, and they are
called by adding parentheses to trigger their actions. Here’s an abstract sampler, but
stay tuned for a rehash of this topic in Chapter 19 after we’ve learned more about
function definition:
def function(): ...
def default(): ...
branch = {'spam': lambda: ..., # A table of callable function objects
'ham': function,
'eggs': lambda: ...}
branch.get(choice, default)()
Although dictionary-based multiway branching is useful in programs that deal with
more dynamic data, most programmers will probably find that coding an if statement
is the most straightforward way to perform multiway branching. As a rule of thumb in
coding, when in doubt, err on the side of simplicity and readability; it’s the “Pythonic”
way.
374 | Chapter 12: if Tests and Syntax Rules](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-426-320.jpg)
![Avoid mixing tabs and spaces: New error checking in 3.X
One rule of thumb: although you can use spaces or tabs to indent, it’s usually not a
good idea to mix the two within a block—use one or the other. Technically, tabs count
for enough spaces to move the current column number up to a multiple of 8, and your
code will work if you mix tabs and spaces consistently. However, such code can be
difficult to change. Worse, mixing tabs and spaces makes your code difficult to read
completely apart from Python’s syntax rules—tabs may look very different in the next
programmer’s editor than they do in yours.
In fact, Python 3.X issues an error, for these very reasons, when a script mixes tabs and
spaces for indentation inconsistently within a block (that is, in a way that makes it
dependent on a tab’s equivalent in spaces). Python 2.X allows such scripts to run, but
it has a -t command-line flag that will warn you about inconsistent tab usage and a
-tt flag that will issue errors for such code (you can use these switches in a command
line like python –t main.py in a system shell window). Python 3.X’s error case is equiv-
alent to 2.X’s -tt switch.
Statement Delimiters: Lines and Continuations
A statement in Python normally ends at the end of the line on which it appears. When
a statement is too long to fit on a single line, though, a few special rules may be used
to make it span multiple lines:
• Statements may span multiple lines if you’re continuing an open syntactic
pair. Python lets you continue typing a statement on the next line if you’re coding
something enclosed in a (), {}, or [] pair. For instance, expressions in parentheses
and dictionary and list literals can span any number of lines; your statement doesn’t
end until the Python interpreter reaches the line on which you type the closing part
of the pair (a ), }, or ]). Continuation lines—lines 2 and beyond of the statement
—can start at any indentation level you like, but you should try to make them align
vertically for readability if possible. This open pairs rule also covers set and dic-
tionary comprehensions in Python 3.X and 2.7.
• Statements may span multiple lines if they end in a backslash. This is a some-
what outdated feature that’s not generally recommended, but if a statement needs
to span multiple lines, you can also add a backslash (a not embedded in a string
literal or comment) at the end of the prior line to indicate you’re continuing on the
next line. Because you can also continue by adding parentheses around most con-
structs, backslashes are rarely used today. This approach is also error-prone: ac-
cidentally forgetting a usually generates a syntax error and might even cause the
next line to be silently mistaken (i.e., without warning) for a new statement, with
unexpected results.
• Special rules for string literals. As we learned in Chapter 7, triple-quoted string
blocks are designed to span multiple lines normally. We also learned in Chap-
ter 7 that adjacent string literals are implicitly concatenated; when it’s used in
378 | Chapter 12: if Tests and Syntax Rules](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-430-320.jpg)
![conjunction with the open pairs rule mentioned earlier, wrapping this construct in
parentheses allows it to span multiple lines.
• Other rules. There are a few other points to mention with regard to statement
delimiters. Although it is uncommon, you can terminate a statement with a semi-
colon—this convention is sometimes used to squeeze more than one simple (non-
compound) statement onto a single line. Also, comments and blank lines can ap-
pear anywhere in a file; comments (which begin with a # character) terminate at
the end of the line on which they appear.
A Few Special Cases
Here’s what a continuation line looks like using the open syntactic pairs rule just de-
scribed. Delimited constructs, such as lists in square brackets, can span across any
number of lines:
L = ["Good",
"Bad",
"Ugly"] # Open pairs may span lines
This also works for anything in parentheses (expressions, function arguments, function
headers, tuples, and generator expressions), as well as anything in curly braces (dic-
tionaries and, in 3.X and 2.7, set literals and set and dictionary comprehensions). Some
of these are tools we’ll study in later chapters, but this rule naturally covers most con-
structs that span lines in practice.
If you like using backslashes to continue lines, you can, but it’s not common practice
in Python:
if a == b and c == d and
d == e and f == g:
print('olde') # Backslashes allow continuations...
Because any expression can be enclosed in parentheses, you can usually use the open
pairs technique instead if you need your code to span multiple lines—simply wrap a
part of your statement in parentheses:
if (a == b and c == d and
d == e and e == f):
print('new') # But parentheses usually do too, and are obvious
In fact, backslashes are generally frowned on by most Python developers, because
they’re too easy to not notice and too easy to omit altogether. In the following, x is
assigned 10 with the backslash, as intended; if the backslash is accidentally omitted,
though, x is assigned 6 instead, and no error is reported (the +4 is a valid expression
statement by itself).
In a real program with a more complex assignment, this could be the source of a very
nasty bug:1
x = 1 + 2 + 3 # Omitting the makes this very different!
+4
Python Syntax Revisited | 379](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-431-320.jpg)
![>>> [] or 3
3
>>> [] or {}
{}
In the first line of the preceding example, both operands (2 and 3) are true (i.e., are
nonzero), so Python always stops and returns the one on the left—it determines the
result because true or anything is always true. In the other two tests, the left operand
is false (an empty object), so Python simply evaluates and returns the object on the
right—which may happen to have either a true or a false value when tested.
Python and operations also stop as soon as the result is known; however, in this case
Python evaluates the operands from left to right and stops if the left operand is a false
object because it determines the result—false and anything is always false:
>>> 2 and 3, 3 and 2 # Return left operand if false
(3, 2) # Else, return right operand (true or false)
>>> [] and {}
[]
>>> 3 and []
[]
Here, both operands are true in the first line, so Python evaluates both sides and returns
the object on the right. In the second test, the left operand is false ([]), so Python stops
and returns it as the test result. In the last test, the left side is true (3), so Python evaluates
and returns the object on the right—which happens to be a false [].
The end result of all this is the same as in C and most other languages—you get a value
that is logically true or false if tested in anif or while according to the normal definitions
of or and and. However, in Python Booleans return either the left or the right object,
not a simple integer flag.
This behavior of and and or may seem esoteric at first glance, but see this chapter’s
sidebar “Why You Will Care: Booleans” on page 384 for examples of how it is some-
times used to advantage in coding by Python programmers. The next section also shows
a common way to leverage this behavior, and its more mnemonic replacement in recent
versions of Python.
The if/else Ternary Expression
One common role for the prior section’s Boolean operators is to code an expression
that runs the same as an if statement. Consider the following statement, which sets
A to either Y or Z, based on the truth value of X:
if X:
A = Y
else:
A = Z
382 | Chapter 12: if Tests and Syntax Rules](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-434-320.jpg)
![Sometimes, though, the items involved in such a statement are so simple that it seems
like overkill to spread them across four lines. At other times, we may want to nest such
a construct in a larger statement instead of assigning its result to a variable. For these
reasons (and, frankly, because the C language has a similar tool), Python 2.5 introduced
a new expression format that allows us to say the same thing in one expression:
A = Y if X else Z
This expression has the exact same effect as the preceding four-line if statement, but
it’s simpler to code. As in the statement equivalent, Python runs expression Y only if
X turns out to be true, and runs expression Z only if X turns out to be false. That is, it
short-circuits, just like the Boolean operators described in the prior section, running
just Y or Z but not both. Here are some examples of it in action:
>>> A = 't' if 'spam' else 'f' # For strings, nonempty means true
>>> A
't'
>>> A = 't' if '' else 'f'
>>> A
'f'
Prior to Python 2.5 (and after 2.5, if you insist), the same effect can often be achieved
by a careful combination of the and and or operators, because they return either the
object on the left side or the object on the right as the preceding section described:
A = ((X and Y) or Z)
This works, but there is a catch—you have to be able to assume that Y will be Boolean
true. If that is the case, the effect is the same: the and runs first and returns Y if X is true;
if X if false the and skips Y, and the or simply returns Z. In other words, we get “if X then
Y else Z.” This is equivalent to the ternary form:
A = Y if X else Z
The and/or combination form also seems to require a “moment of great clarity” to
understand the first time you see it, and it’s no longer required as of 2.5—use the
equivalent and more robust and mnemonic if/else expression when you need this
structure, or use a full if statement if the parts are nontrivial.
As a side note, using the following expression in Python is similar because the bool
function will translate X into the equivalent of integer 1 or 0, which can then be used as
offsets to pick true and false values from a list:
A = [Z, Y][bool(X)]
For example:
>>> ['f', 't'][bool('')]
'f'
>>> ['f', 't'][bool('spam')]
't'
However, this isn’t exactly the same, because Python will not short-circuit—it will al-
ways run both Z and Y, regardless of the value of X. Because of such complexities, you’re
The if/else Ternary Expression | 383](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-435-320.jpg)
![(X = False), for loop tests (while True:), and for displaying results at the interactive
prompt.
Also watch for related discussion in operator overloading in Part VI: when we define
new object types with classes, we can specify their Boolean nature with either the
__bool__ or __len__ methods (__bool__ is named __nonzero__ in 2.7). The latter of these
is tried if the former is absent and designates false by returning a length of zero—an
empty object is considered false.
Finally, and as a preview, other tools in Python have roles similar to the or chains at
the start of this sidebar: the filter call and list comprehensions we’ll meet later can be
used to select true values when the set of candidates isn’t known until runtime (though
they evaluate all values and return all that are true), and the any and all built-ins can
be used to test if any or all items in a collection are true (though they don’t select an
item):
>>> L = [1, 0, 2, 0, 'spam', '', 'ham', []]
>>> list(filter(bool, L)) # Get true values
[1, 2, 'spam', 'ham']
>>> [x for x in L if x] # Comprehensions
[1, 2, 'spam', 'ham']
>>> any(L), all(L) # Aggregate truth
(True, False)
As seen in Chapter 9, the bool function here simply returns its argument’s true or false
value, as though it were tested in an if. Watch for more on these related tools in
Chapter 14, Chapter 19, and Chapter 20.
Chapter Summary
In this chapter, we studied the Python if statement. Additionally, because this was our
first compound and logical statement, we reviewed Python’s general syntax rules and
explored the operation of truth values and tests in more depth than we were able to
previously. Along the way, we also looked at how to code multiway branching in
Python, learned about the if/else expression introduced in Python 2.5, and explored
some common ways that Boolean values crop up in code.
The next chapter continues our look at procedural statements by expanding on the
while and for loops. There, we’ll learn about alternative ways to code loops in Python,
some of which may be better than others. Before that, though, here is the usual chapter
quiz.
Test Your Knowledge: Quiz
1. How might you code a multiway branch in Python?
2. How can you code an if/else statement as an expression in Python?
3. How can you make a single statement span many lines?
Test Your Knowledge: Quiz | 385](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-437-320.jpg)
![4. What do the words True and False mean?
Test Your Knowledge: Answers
1. An if statement with multiple elif clauses is often the most straightforward way
to code a multiway branch, though not necessarily the most concise or flexible.
Dictionary indexing can often achieve the same result, especially if the dictionary
contains callable functions coded with def statements or lambda expressions.
2. In Python 2.5 and later, the expression form Y if X else Z returns Y if X is true, or
Z otherwise; it’s the same as a four-line if statement. The and/or combination
(((X and Y) or Z)) can work the same way, but it’s more obscure and requires that
the Y part be true.
3. Wrap up the statement in an open syntactic pair ((), [], or {}), and it can span as
many lines as you like; the statement ends when Python sees the closing (right) half
of the pair, and lines 2 and beyond of the statement can begin at any indentation
level. Backslash continuations work too, but are broadly discouraged in the Python
world.
4. True and False are just custom versions of the integers 1 and 0, respectively: they
always stand for Boolean true and false values in Python. They’re available for use
in truth tests and variable initialization, and are printed for expression results at
the interactive prompt. In all these roles, they serve as a more mnemonic and hence
readable alternative to 1 and 0.
386 | Chapter 12: if Tests and Syntax Rules](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-438-320.jpg)
![General Format
In its most complex form, the while statement consists of a header line with a test
expression, a body of one or more normally indented statements, and an optional
else part that is executed if control exits the loop without a break statement being
encountered. Python keeps evaluating the test at the top and executing the statements
nested in the loop body until the test returns a false value:
while test: # Loop test
statements # Loop body
else: # Optional else
statements # Run if didn't exit loop with break
Examples
To illustrate, let’s look at a few simple while loops in action. The first, which consists
of a print statement nested in a while loop, just prints a message forever. Recall that
True is just a custom version of the integer 1 and always stands for a Boolean true value;
because the test is always true, Python keeps executing the body forever, or until you
stop its execution. This sort of behavior is usually called an infinite loop—it’s not really
immortal, but you may need a Ctrl-C key combination to forcibly terminate one:
>>> while True:
... print('Type Ctrl-C to stop me!')
The next example keeps slicing off the first character of a string until the string is empty
and hence false. It’s typical to test an object directly like this instead of using the more
verbose equivalent (while x != '':). Later in this chapter, we’ll see other ways to step
through the items in a string more easily with a for loop.
>>> x = 'spam'
>>> while x: # While x is not empty
... print(x, end=' ') # In 2.X use print x,
... x = x[1:] # Strip first character off x
...
spam pam am m
Note the end=' ' keyword argument used here to place all outputs on the same line
separated by a space; see Chapter 11 if you’ve forgotten why this works as it does. This
may leave your input prompt in an odd state at the end of your output; type Enter to
reset. Python 2.X readers: also remember to use a trailing comma instead of end in the
prints like this.
The following code counts from the value of a up to, but not including, b. We’ll also
see an easier way to do this with a Python for loop and the built-in range function later:
>>> a=0; b=10
>>> while a < b: # One way to code counter loops
... print(a, end=' ')
... a += 1 # Or, a = a + 1
388 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-440-320.jpg)
![This example determines primes, but only informally so. Numbers less
than 2 are not considered prime by the strict mathematical definition.
To be really picky, this code also fails for negative numbers and succeeds
for floating-point numbers with no decimal digits. Also note that its
code must use // instead of / in Python 3.X because of the migration
of / to “true division,” as described in Chapter 5 (we need the initial
division to truncate remainders, not retain them!). If you want to ex-
periment with this code, be sure to see the exercise at the end of
Part IV, which wraps it in a function for reuse.
More on the loop else
Because the loop else clause is unique to Python, it tends to perplex some newcomers
(and go unused by some veterans; I’ve met some who didn’t even know there was an
else on loops!). In general terms, the loop else simply provides explicit syntax for a
common coding scenario—it is a coding structure that lets us catch the “other” way
out of a loop, without setting and checking flags or conditions.
Suppose, for instance, that we are writing a loop to search a list for a value, and we
need to know whether the value was found after we exit the loop. We might code such
a task this way (this code is intentionally abstract and incomplete; x is a sequence and
match is a tester function to be defined):
found = False
while x and not found:
if match(x[0]): # Value at front?
print('Ni')
found = True
else:
x = x[1:] # Slice off front and repeat
if not found:
print('not found')
Here, we initialize, set, and later test a flag to determine whether the search succeeded
or not. This is valid Python code, and it does work; however, this is exactly the sort of
structure that the loop else clause is there to handle. Here’s an else equivalent:
while x: # Exit when x empty
if match(x[0]):
print('Ni')
break # Exit, go around else
x = x[1:]
else:
print('Not found') # Only here if exhausted x
This version is more concise. The flag is gone, and we’ve replaced the if test at the loop
end with an else (lined up vertically with the word while). Because the break inside the
main part of the while exits the loop and goes around the else, this serves as a more
structured way to catch the search-failure case.
break, continue, pass, and the Loop else | 393](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-445-320.jpg)
![Basic usage
As mentioned earlier, a for loop can step across any kind of sequence object. In our
first example, for instance, we’ll assign the name x to each of the three items in a list in
turn, from left to right, and the print statement will be executed for each. Inside the
print statement (the loop body), the name x refers to the current item in the list:
>>> for x in ["spam", "eggs", "ham"]:
... print(x, end=' ')
...
spam eggs ham
The next two examples compute the sum and product of all the items in a list. Later in
this chapter and later in the book we’ll meet tools that apply operations such as + and
* to items in a list automatically, but it’s often just as easy to use a for:
>>> sum = 0
>>> for x in [1, 2, 3, 4]:
... sum = sum + x
...
>>> sum
10
>>> prod = 1
>>> for item in [1, 2, 3, 4]: prod *= item
...
>>> prod
24
Other data types
Any sequence works in a for, as it’s a generic tool. For example, for loops work on
strings and tuples:
>>> S = "lumberjack"
>>> T = ("and", "I'm", "okay")
>>> for x in S: print(x, end=' ') # Iterate over a string
...
l u m b e r j a c k
>>> for x in T: print(x, end=' ') # Iterate over a tuple
...
and I'm okay
In fact, as we’ll learn in the next chapter when we explore the notion of “iterables,”
for loops can even work on some objects that are not sequences—files and dictionaries
work, too.
Tuple assignment in for loops
If you’re iterating through a sequence of tuples, the loop target itself can actually be a
tuple of targets. This is just another case of the tuple-unpacking assignment we studied
396 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-448-320.jpg)
![in Chapter 11 at work. Remember, the for loop assigns items in the sequence object
to the target, and assignment works the same everywhere:
>>> T = [(1, 2), (3, 4), (5, 6)]
>>> for (a, b) in T: # Tuple assignment at work
... print(a, b)
...
1 2
3 4
5 6
Here, the first time through the loop is like writing (a,b) = (1,2), the second time is
like writing (a,b) = (3,4), and so on. The net effect is to automatically unpack the
current tuple on each iteration.
This form is commonly used in conjunction with the zip call we’ll meet later in this
chapter to implement parallel traversals. It also makes regular appearances in conjunc-
tion with SQL databases in Python, where query result tables are returned as sequences
of sequences like the list used here—the outer list is the database table, the nested tuples
are the rows within the table, and tuple assignment extracts columns.
Tuples in for loops also come in handy to iterate through both keys and values in
dictionaries using the items method, rather than looping through the keys and indexing
to fetch the values manually:
>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> for key in D:
... print(key, '=>', D[key]) # Use dict keys iterator and index
...
a => 1
c => 3
b => 2
>>> list(D.items())
[('a', 1), ('c', 3), ('b', 2)]
>>> for (key, value) in D.items():
... print(key, '=>', value) # Iterate over both keys and values
...
a => 1
c => 3
b => 2
It’s important to note that tuple assignment in for loops isn’t a special case; any as-
signment target works syntactically after the word for. We can always assign manually
within the loop to unpack:
>>> T
[(1, 2), (3, 4), (5, 6)]
>>> for both in T:
... a, b = both # Manual assignment equivalent
... print(a, b) # 2.X: prints with enclosing tuple "()"
...
for Loops | 397](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-449-320.jpg)
![1 2
3 4
5 6
But tuples in the loop header save us an extra step when iterating through sequences
of sequences. As suggested in Chapter 11, even nested structures may be automatically
unpacked this way in a for:
>>> ((a, b), c) = ((1, 2), 3) # Nested sequences work too
>>> a, b, c
(1, 2, 3)
>>> for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: print(a, b, c)
...
1 2 3
4 5 6
Even this is not a special case, though—the for loop simply runs the sort of assignment
we ran just before it, on each iteration. Any nested sequence structure may be unpacked
this way, simply because sequence assignment is so generic:
>>> for ((a, b), c) in [([1, 2], 3), ['XY', 6]]: print(a, b, c)
...
1 2 3
X Y 6
Python 3.X extended sequence assignment in for loops
In fact, because the loop variable in a for loop can be any assignment target, we can
also use Python 3.X’s extended sequence-unpacking assignment syntax here to extract
items and sections of sequences within sequences. Really, this isn’t a special case either,
but simply a new assignment form in 3.X, as discussed in Chapter 11; because it works
in assignment statements, it automatically works in for loops.
Consider the tuple assignment form introduced in the prior section. A tuple of values
is assigned to a tuple of names on each iteration, exactly like a simple assignment state-
ment:
>>> a, b, c = (1, 2, 3) # Tuple assignment
>>> a, b, c
(1, 2, 3)
>>> for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: # Used in for loop
... print(a, b, c)
...
1 2 3
4 5 6
In Python 3.X, because a sequence can be assigned to a more general set of names with
a starred name to collect multiple items, we can use the same syntax to extract parts of
nested sequences in the for loop:
>>> a, *b, c = (1, 2, 3, 4) # Extended seq assignment
>>> a, b, c
398 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-450-320.jpg)
![(1, [2, 3], 4)
>>> for (a, *b, c) in [(1, 2, 3, 4), (5, 6, 7, 8)]:
... print(a, b, c)
...
1 [2, 3] 4
5 [6, 7] 8
In practice, this approach might be used to pick out multiple columns from rows of
data represented as nested sequences. In Python 2.X starred names aren’t allowed, but
you can achieve similar effects by slicing. The only difference is that slicing returns a
type-specific result, whereas starred names always are assigned lists:
>>> for all in [(1, 2, 3, 4), (5, 6, 7, 8)]: # Manual slicing in 2.X
... a, b, c = all[0], all[1:3], all[3]
... print(a, b, c)
...
1 (2, 3) 4
5 (6, 7) 8
See Chapter 11 for more on this assignment form.
Nested for loops
Now let’s look at a for loop that’s a bit more sophisticated than those we’ve seen so
far. The next example illustrates statement nesting and the loop else clause in a for.
Given a list of objects (items) and a list of keys (tests), this code searches for each key
in the objects list and reports on the search’s outcome:
>>> items = ["aaa", 111, (4, 5), 2.01] # A set of objects
>>> tests = [(4, 5), 3.14] # Keys to search for
>>>
>>> for key in tests: # For all keys
... for item in items: # For all items
... if item == key: # Check for match
... print(key, "was found")
... break
... else:
... print(key, "not found!")
...
(4, 5) was found
3.14 not found!
Because the nested if runs a break when a match is found, the loop else clause can
assume that if it is reached, the search has failed. Notice the nesting here. When this
code runs, there are two loops going at the same time: the outer loop scans the keys
list, and the inner loop scans the items list for each key. The nesting of the loop else
clause is critical; it’s indented to the same level as the header line of the inner for loop,
so it’s associated with the inner loop, not the if or the outer for.
This example is illustrative, but it may be easier to code if we employ the in operator
to test membership. Because in implicitly scans an object looking for a match (at least
logically), it replaces the inner loop:
for Loops | 399](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-451-320.jpg)
![>>> for key in tests: # For all keys
... if key in items: # Let Python check for a match
... print(key, "was found")
... else:
... print(key, "not found!")
...
(4, 5) was found
3.14 not found!
In general, it’s a good idea to let Python do as much of the work as possible (as in this
solution) for the sake of brevity and performance.
The next example is similar, but builds a list as it goes for later use instead of printing.
It performs a typical data-structure task with a for—collecting common items in two
sequences (strings)—and serves as a rough set intersection routine. After the loop runs,
res refers to a list that contains all the items found in seq1 and seq2:
>>> seq1 = "spam"
>>> seq2 = "scam"
>>>
>>> res = [] # Start empty
>>> for x in seq1: # Scan first sequence
... if x in seq2: # Common item?
... res.append(x) # Add to result end
...
>>> res
['s', 'a', 'm']
Unfortunately, this code is equipped to work only on two specific variables: seq1 and
seq2. It would be nice if this loop could somehow be generalized into a tool you could
use more than once. As you’ll see, that simple idea leads us to functions, the topic of
the next part of the book.
This code also exhibits the classic list comprehension pattern—collecting a results list
with an iteration and optional filter test—and could be coded more concisely too:
>>> [x for x in seq1 if x in seq2] # Let Python collect results
['s', 'a', 'm']
But you’ll have to read on to the next chapter for the rest of this story.
Why You Will Care: File Scanners
In general, loops come in handy anywhere you need to repeat an operation or process
something more than once. Because files contain multiple characters and lines, they are
one of the more typical use cases for loops. To load a file’s contents into a string all at
once, you simply call the file object’s read method:
file = open('test.txt', 'r') # Read contents into a string
print(file.read())
But to load a file in smaller pieces, it’s common to code either a while loop with breaks
on end-of-file, or a for loop. To read by characters, either of the following codings will
suffice:
400 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-452-320.jpg)
![Python 2.X range creates a physical list; in 3.X, range is an iterable that generates items
on demand, so we need to wrap it in a list call to display its results all at once in 3.X
only:
>>> list(range(5)), list(range(2, 5)), list(range(0, 10, 2))
([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])
With one argument, range generates a list of integers from zero up to but not including
the argument’s value. If you pass in two arguments, the first is taken as the lower bound.
An optional third argument can give a step; if it is used, Python adds the step to each
successive integer in the result (the step defaults to +1). Ranges can also be nonpositive
and nonascending, if you want them to be:
>>> list(range(−5, 5))
[−5, −4, −3, −2, −1, 0, 1, 2, 3, 4]
>>> list(range(5, −5, −1))
[5, 4, 3, 2, 1, 0, −1, −2, −3, −4]
We’ll get more formal about iterables like this one in Chapter 14. There, we’ll also see
that Python 2.X has a cousin named xrange, which is like its range but doesn’t build
the result list in memory all at once. This is a space optimization, which is subsumed
in 3.X by the generator behavior of its range.
Although such range results may be useful all by themselves, they tend to come in most
handy within for loops. For one thing, they provide a simple way to repeat an action
a specific number of times. To print three lines, for example, use a range to generate
the appropriate number of integers:
>>> for i in range(3):
... print(i, 'Pythons')
...
0 Pythons
1 Pythons
2 Pythons
Note that for loops force results from range automatically in 3.X, so we don’t need to
use a list wrapper here in 3.X (in 2.X we get a temporary list unless we call xrange
instead).
Sequence Scans: while and range Versus for
The range call is also sometimes used to iterate over a sequence indirectly, though it’s
often not the best approach in this role. The easiest and generally fastest way to step
through a sequence exhaustively is always with a simple for, as Python handles most
of the details for you:
>>> X = 'spam'
>>> for item in X: print(item, end=' ') # Simple iteration
...
s p a m
Loop Coding Techniques | 403](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-455-320.jpg)
![Internally, the for loop handles the details of the iteration automatically when used
this way. If you really need to take over the indexing logic explicitly, you can do it with
a while loop:
>>> i = 0
>>> while i < len(X): # while loop iteration
... print(X[i], end=' ')
... i += 1
...
s p a m
You can also do manual indexing with a for, though, if you use range to generate a list
of indexes to iterate through. It’s a multistep process, but it’s sufficient to generate
offsets, rather than the items at those offsets:
>>> X
'spam'
>>> len(X) # Length of string
4
>>> list(range(len(X))) # All legal offsets into X
[0, 1, 2, 3]
>>>
>>> for i in range(len(X)): print(X[i], end=' ') # Manual range/len iteration
...
s p a m
Note that because this example is stepping over a list of offsets into X, not the actual
items of X, we need to index back into X within the loop to fetch each item. If this seems
like overkill, though, it’s because it is: there’s really no reason to work this hard in this
example.
Although the range/len combination suffices in this role, it’s probably not the best
option. It may run slower, and it’s also more work than we need to do. Unless you have
a special indexing requirement, you’re better off using the simple for loop form in
Python:
>>> for item in X: print(item, end=' ') # Use simple iteration if you can
As a general rule, use for instead of while whenever possible, and don’t use range calls
in for loops except as a last resort. This simpler solution is almost always better. Like
every good rule, though, there are plenty of exceptions—as the next section demon-
strates.
Sequence Shufflers: range and len
Though not ideal for simple sequence scans, the coding pattern used in the prior ex-
ample does allow us to do more specialized sorts of traversals when required. For ex-
ample, some algorithms can make use of sequence reordering—to generate alternatives
in searches, to test the effect of different value orderings, and so on. Such cases may
require offsets in order to pull sequences apart and put them back together, as in the
404 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-456-320.jpg)
![following; the range’s integers provide a repeat count in the first, and a position for
slicing in the second:
>>> S = 'spam'
>>> for i in range(len(S)): # For repeat counts 0..3
... S = S[1:] + S[:1] # Move front item to end
... print(S, end=' ')
...
pams amsp mspa spam
>>> S
'spam'
>>> for i in range(len(S)): # For positions 0..3
... X = S[i:] + S[:i] # Rear part + front part
... print(X, end=' ')
...
spam pams amsp mspa
Trace through these one iteration at a time if they seem confusing. The second creates
the same results as the first, though in a different order, and doesn’t change the original
variable as it goes. Because both slice to obtain parts to concatenate, they also work on
any type of sequence, and return sequences of the same type as that being shuffled—
if you shuffle a list, you create reordered lists:
>>> L = [1, 2, 3]
>>> for i in range(len(L)):
... X = L[i:] + L[:i] # Works on any sequence type
... print(X, end=' ')
...
[1, 2, 3] [2, 3, 1] [3, 1, 2]
We’ll make use of code like this to test functions with different argument orderings in
Chapter 18, and will extend it to functions, generators, and more complete permuta-
tions in Chapter 20—it’s a widely useful tool.
Nonexhaustive Traversals: range Versus Slices
Cases like that of the prior section are valid applications for the range/len combination.
We might also use this technique to skip items as we go:
>>> S = 'abcdefghijk'
>>> list(range(0, len(S), 2))
[0, 2, 4, 6, 8, 10]
>>> for i in range(0, len(S), 2): print(S[i], end=' ')
...
a c e g i k
Here, we visit every second item in the string S by stepping over the generated range
list. To visit every third item, change the third range argument to be 3, and so on. In
effect, using range this way lets you skip items in loops while still retaining the simplicity
of the for loop construct.
Loop Coding Techniques | 405](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-457-320.jpg)
![In most cases, though, this is also probably not the “best practice” technique in Python
today. If you really mean to skip items in a sequence, the extended three-limit form of
the slice expression, presented in Chapter 7, provides a simpler route to the same goal.
To visit every second character in S, for example, slice with a stride of 2:
>>> S = 'abcdefghijk'
>>> for c in S[::2]: print(c, end=' ')
...
a c e g i k
The result is the same, but substantially easier for you to write and for others to read.
The potential advantage to using range here instead is space: slicing makes a copy of
the string in both 2.X and 3.X, while range in 3.X and xrange in 2.X do not create a list;
for very large strings, they may save memory.
Changing Lists: range Versus Comprehensions
Another common place where you may use the range/len combination with for is in
loops that change a list as it is being traversed. Suppose, for example, that you need to
add 1 to every item in a list (maybe you’re giving everyone a raise in an employee
database list). You can try this with a simple for loop, but the result probably won’t
be exactly what you want:
>>> L = [1, 2, 3, 4, 5]
>>> for x in L:
... x += 1 # Changes x, not L
...
>>> L
[1, 2, 3, 4, 5]
>>> x
6
This doesn’t quite work—it changes the loop variable x, not the list L. The reason is
somewhat subtle. Each time through the loop, x refers to the next integer already pulled
out of the list. In the first iteration, for example, x is integer 1. In the next iteration, the
loop body sets x to a different object, integer 2, but it does not update the list where 1
originally came from; it’s a piece of memory separate from the list.
To really change the list as we march across it, we need to use indexes so we can assign
an updated value to each position as we go. The range/len combination can produce
the required indexes for us:
>>> L = [1, 2, 3, 4, 5]
>>> for i in range(len(L)): # Add one to each item in L
... L[i] += 1 # Or L[i] = L[i] + 1
...
>>> L
[2, 3, 4, 5, 6]
406 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-458-320.jpg)
![When coded this way, the list is changed as we proceed through the loop. There is no
way to do the same with a simple for x in L:–style loop, because such a loop iterates
through actual items, not list positions. But what about the equivalent while loop? Such
a loop requires a bit more work on our part, and might run more slowly depending on
your Python (it does on 2.7 and 3.3, though less so on 3.3—we’ll see how to verify this
in Chapter 21):
>>> i = 0
>>> while i < len(L):
... L[i] += 1
... i += 1
...
>>> L
[3, 4, 5, 6, 7]
Here again, though, the range solution may not be ideal either. A list comprehension
expression of the form:
[x + 1 for x in L]
likely runs faster today and would do similar work, albeit without changing the original
list in place (we could assign the expression’s new list object result back to L, but this
would not update any other references to the original list). Because this is such a central
looping concept, we’ll save a complete exploration of list comprehensions for the next
chapter, and continue this story there.
Parallel Traversals: zip and map
Our next loop coding technique extends a loop’s scope. As we’ve seen, the range built-
in allows us to traverse sequences with for in a nonexhaustive fashion. In the same
spirit, the built-in zip function allows us to use for loops to visit multiple sequences
in parallel—not overlapping in time, but during the same loop. In basic operation,
zip takes one or more sequences as arguments and returns a series of tuples that pair
up parallel items taken from those sequences. For example, suppose we’re working
with two lists (a list of names and addresses paired by position, perhaps):
>>> L1 = [1,2,3,4]
>>> L2 = [5,6,7,8]
To combine the items in these lists, we can use zip to create a list of tuple pairs. Like
range, zip is a list in Python 2.X, but an iterable object in 3.X where we must wrap it
in a list call to display all its results at once (again, there’s more on iterables coming
up in the next chapter):
>>> zip(L1, L2)
<zip object at 0x026523C8>
>>> list(zip(L1, L2)) # list() required in 3.X, not 2.X
[(1, 5), (2, 6), (3, 7), (4, 8)]
Such a result may be useful in other contexts as well, but when wedded with the for
loop, it supports parallel iterations:
Loop Coding Techniques | 407](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-459-320.jpg)
![>>> for (x, y) in zip(L1, L2):
... print(x, y, '--', x+y)
...
1 5 -- 6
2 6 -- 8
3 7 -- 10
4 8 -- 12
Here, we step over the result of the zip call—that is, the pairs of items pulled from the
two lists. Notice that this for loop again uses the tuple assignment form we met earlier
to unpack each tuple in the zip result. The first time through, it’s as though we ran the
assignment statement (x, y) = (1, 5).
The net effect is that we scan both L1 and L2 in our loop. We could achieve a similar
effect with a while loop that handles indexing manually, but it would require more
typing and would likely run more slowly than the for/zip approach.
Strictly speaking, the zip function is more general than this example suggests. For in-
stance, it accepts any type of sequence (really, any iterable object, including files), and
it accepts more than two arguments. With three arguments, as in the following exam-
ple, it builds a list of three-item tuples with items from each sequence, essentially pro-
jecting by columns (technically, we get an N-ary tuple for N arguments):
>>> T1, T2, T3 = (1,2,3), (4,5,6), (7,8,9)
>>> T3
(7, 8, 9)
>>> list(zip(T1, T2, T3)) # Three tuples for three arguments
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
Moreover, zip truncates result tuples at the length of the shortest sequence when the
argument lengths differ. In the following, we zip together two strings to pick out char-
acters in parallel, but the result has only as many tuples as the length of the shortest
sequence:
>>> S1 = 'abc'
>>> S2 = 'xyz123'
>>>
>>> list(zip(S1, S2)) # Truncates at len(shortest)
[('a', 'x'), ('b', 'y'), ('c', 'z')]
map equivalence in Python 2.X
In Python 2.X only, the related built-in map function pairs items from sequences in a
similar fashion when passed None for its function argument, but it pads shorter se-
quences with None if the argument lengths differ instead of truncating to the shortest
length:
>>> S1 = 'abc'
>>> S2 = 'xyz123'
>>> map(None, S1, S2) # 2.X only: pads to len(longest)
[('a', 'x'), ('b', 'y'), ('c', 'z'), (None, '1'), (None, '2'), (None,'3')]
408 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-460-320.jpg)
![Thisexampleisusingadegenerateformofthemap built-in,whichisnolongersupported
in 3.X. Normally, map takes a function and one or more sequence arguments and collects
the results of calling the function with parallel items taken from the sequence(s).
We’ll study map in detail in Chapter 19 and Chapter 20, but as a brief example, the
following maps the built-in ord function across each item in a string and collects the
results (like zip, map is a value generator in 3.X and so must be passed to list to collect
all its results at once in 3.X only):
>>> list(map(ord, 'spam'))
[115, 112, 97, 109]
This works the same as the following loop statement, but map is often quicker, as
Chapter 21 will show:
>>> res = []
>>> for c in 'spam': res.append(ord(c))
>>> res
[115, 112, 97, 109]
Version skew note: The degenerate form of map using a function argu-
ment of None is no longer supported in Python 3.X, because it largely
overlaps with zip (and was, frankly, a bit at odds with map’s function-
application purpose). In 3.X, either use zip or write loop code to pad
results yourself. In fact, we’ll see how to write such loop code in Chap-
ter 20, after we’ve had a chance to study some additional iteration con-
cepts.
Dictionary construction with zip
Let’s look at another zip use case. Chapter 8 suggested that the zip call used here can
also be handy for generating dictionaries when the sets of keys and values must be
computed at runtime. Now that we’re becoming proficient with zip, let’s explore more
fully how it relates to dictionary construction. As you’ve learned, you can always create
a dictionary by coding a dictionary literal, or by assigning to keys over time:
>>> D1 = {'spam':1, 'eggs':3, 'toast':5}
>>> D1
{'eggs': 3, 'toast': 5, 'spam': 1}
>>> D1 = {}
>>> D1['spam'] = 1
>>> D1['eggs'] = 3
>>> D1['toast'] = 5
What to do, though, if your program obtains dictionary keys and values in lists at
runtime, after you’ve coded your script? For example, say you had the following keys
and values lists, collected from a user, parsed from a file, or obtained from another
dynamic source:
Loop Coding Techniques | 409](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-461-320.jpg)
![>>> keys = ['spam', 'eggs', 'toast']
>>> vals = [1, 3, 5]
One solution for turning those lists into a dictionary would be to zip the lists and step
through them in parallel with a for loop:
>>> list(zip(keys, vals))
[('spam', 1), ('eggs', 3), ('toast', 5)]
>>> D2 = {}
>>> for (k, v) in zip(keys, vals): D2[k] = v
...
>>> D2
{'eggs': 3, 'toast': 5, 'spam': 1}
It turns out, though, that in Python 2.2 and later you can skip the for loop altogether
and simply pass the zipped keys/values lists to the built-in dict constructor call:
>>> keys = ['spam', 'eggs', 'toast']
>>> vals = [1, 3, 5]
>>> D3 = dict(zip(keys, vals))
>>> D3
{'eggs': 3, 'toast': 5, 'spam': 1}
The built-in name dict is really a type name in Python (you’ll learn more about type
names, and subclassing them, in Chapter 32). Calling it achieves something like a list-
to-dictionary conversion, but it’s really an object construction request.
In the next chapter we’ll explore the related but richer concept, the list comprehension,
which builds lists in a single expression; we’ll also revisit Python 3.X and 2.7 dictionary
comprehensions, an alternative to the dict call for zipped key/value pairs:
>>> {k: v for (k, v) in zip(keys, vals)}
{'eggs': 3, 'toast': 5, 'spam': 1}
Generating Both Offsets and Items: enumerate
Our final loop helper function is designed to support dual usage modes. Earlier, we
discussed using range to generate the offsets of items in a string, rather than the items
at those offsets. In some programs, though, we need both: the item to use, plus an offset
as we go. Traditionally, this was coded with a simple for loop that also kept a counter
of the current offset:
>>> S = 'spam'
>>> offset = 0
>>> for item in S:
... print(item, 'appears at offset', offset)
... offset += 1
...
s appears at offset 0
p appears at offset 1
a appears at offset 2
m appears at offset 3
410 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-462-320.jpg)
![This works, but in all recent Python 2.X and 3.X releases (since 2.3) a new built-in
named enumerate does the job for us—its net effect is to give loops a counter “for free,”
without sacrificing the simplicity of automatic iteration:
>>> S = 'spam'
>>> for (offset, item) in enumerate(S):
... print(item, 'appears at offset', offset)
...
s appears at offset 0
p appears at offset 1
a appears at offset 2
m appears at offset 3
The enumerate function returns a generator object—a kind of object that supports the
iteration protocol that we will study in the next chapter and will discuss in more detail
in the next part of the book. In short, it has a method called by thenext built-in function,
which returns an (index, value) tuple each time through the loop. The for steps
through these tuples automatically, which allows us to unpack their values with tuple
assignment, much as we did for zip:
>>> E = enumerate(S)
>>> E
<enumerate object at 0x0000000002A8B900>
>>> next(E)
(0, 's')
>>> next(E)
(1, 'p')
>>> next(E)
(2, 'a')
We don’t normally see this machinery because all iteration contexts—including list
comprehensions, the subject of Chapter 14—run the iteration protocol automatically:
>>> [c * i for (i, c) in enumerate(S)]
['', 'p', 'aa', 'mmm']
>>> for (i, l) in enumerate(open('test.txt')):
... print('%s) %s' % (i, l.rstrip()))
...
0) aaaaaa
1) bbbbbb
2) cccccc
To fully understand iteration concepts like enumerate, zip, and list comprehensions,
though, we need to move on to the next chapter for a more formal dissection.
Why You Will Care: Shell Commands and More
An earlier sidebar showed loops applied to files. As briefly noted in Chapter 9, Python’s
related os.popen call also gives a file-like interface, for reading the outputs of spawned
shell commands. Now that we’ve studied looping statements in full, here’s an example
of this tool in action—to run a shell command and read its standard output text, pass
the command as a string to os popen, and read text from the file-like object it returns
Loop Coding Techniques | 411](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-463-320.jpg)
![(if this triggers a Unicode encoding issue on your computer, Chapter 25’s discussion
of currency symbols may apply):
>>> import os
>>> F = os.popen('dir') # Read line by line
>>> F.readline()
' Volume in drive C has no label.n'
>>> F = os.popen('dir') # Read by sized blocks
>>> F.read(50)
' Volume in drive C has no label.n Volume Serial Nu'
>>> os.popen('dir').readlines()[0] # Read all lines: index
' Volume in drive C has no label.n'
>>> os.popen('dir').read()[:50] # Read all at once: slice
' Volume in drive C has no label.n Volume Serial Nu'
>>> for line in os.popen('dir'): # File line iterator loop
... print(line.rstrip())
...
Volume in drive C has no label.
Volume Serial Number is D093-D1F7
...and so on...
This runs a dir directory listing on Windows, but any program that can be started with
a command line can be launched this way. We might use this scheme, for example, to
displaytheoutputofthewindowssysteminfo command—os.system simplyrunsashell
command, but os.popen also connects to its streams; both of the following show the
shell command’s output in a simple console window, but the first might not in a GUI
interface such as IDLE:
>>> os.system('systeminfo')
...output in console, popup in IDLE...
0
>>> for line in os.popen('systeminfo'): print(line.rstrip())
Host Name: MARK-VAIO
OS Name: Microsoft Windows 7 Professional
OS Version: 6.1.7601 Service Pack 1 Build 7601
...lots of system information text...
And once we have a command’s output in text form, any string processing tool or
technique applies—including display formatting and content parsing:
# Formatted, limited display
>>> for (i, line) in enumerate(os.popen('systeminfo')):
... if i == 4: break
... print('%05d) %s' % (i, line.rstrip()))
...
00000)
00001) Host Name: MARK-VAIO
00002) OS Name: Microsoft Windows 7 Professional
00003) OS Version: 6.1.7601 Service Pack 1 Build 7601
# Parse for specific lines, case neutral
>>> for line in os.popen('systeminfo'):
... parts = line.split(':')
... if parts and parts[0].lower() == 'system type':
... print(parts[1].strip())
412 | Chapter 13: while and for Loops](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-464-320.jpg)
![...
x64-based PC
We’ll see os.popen in action again in Chapter 21, where we’ll deploy it to read the results
of a constructed command line that times code alternatives, and in Chapter 25, where
it will be used to compare outputs of scripts being tested.
Tools like os.popen and os.system (and the subprocess module not shown here) allow
you to leverage every command-line program on your computer, but you can also write
emulators with in-process code. For example, simulating the Unix awk utility’s ability
to strip columns out of text files is almost trivial in Python, and can become a reusable
function in the process:
# awk emulation: extract column 7 from whitespace-delimited file
for val in [line.split()[6] for line in open('input.txt')]:
print(val)
# Same, but more explicit code that retains result
col7 = []
for line in open('input.txt'):
cols = line.split()
col7.append(cols[6])
for item in col7: print(item)
# Same, but a reusable function (see next part of book)
def awker(file, col):
return [line.rstrip().split()[col-1] for line in open(file)]
print(awker('input.txt', 7)) # List of strings
print(','.join(awker('input.txt', 7))) # Put commas between
By itself, though, Python provides file-like access to a wide variety of data—including
the text returned by websites and their pages identified by URL, though we’ll have to
defer to Part V for more on the package import used here, and other resources for more
on such tools in general (e.g., this works in 2.X, but uses urllib instead of
urlib.request, and returns text strings):
>>> from urllib.request import urlopen
>>> for line in urlopen('http://home.rmi.net/~lutz'):
... print(line)
...
b'<HTML>n'
b'n'
b'<HEAD>n'
b"<TITLE>Mark Lutz's Book Support Site</TITLE>n"
...etc...
Chapter Summary
In this chapter, we explored Python’s looping statements as well as some concepts
related to looping in Python. We looked at the while and for loop statements in depth,
and we learned about their associated else clauses. We also studied the break and
continue statements, which have meaning only inside loops, and met several built-in
Chapter Summary | 413](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-465-320.jpg)
![Iterations: A First Look
In the preceding chapter, I mentioned that the for loop can work on any sequence type
in Python, including lists, tuples, and strings, like this:
>>> for x in [1, 2, 3, 4]: print(x ** 2, end=' ') # In 2.X: print x ** 2,
...
1 4 9 16
>>> for x in (1, 2, 3, 4): print(x ** 3, end=' ')
...
1 8 27 64
>>> for x in 'spam': print(x * 2, end=' ')
...
ss pp aa mm
Actually, the for loop turns out to be even more generic than this—it works on any
iterable object. In fact, this is true of all iteration tools that scan objects from left to right
in Python, including for loops, the list comprehensions we’ll study in this chapter, in
membership tests, the map built-in function, and more.
The concept of “iterable objects” is relatively recent in Python, but it has come to
permeate the language’s design. It’s essentially a generalization of the notion of se-
quences—an object is considered iterable if it is either a physically stored sequence, or
an object that produces one result at a time in the context of an iteration tool like a
for loop. In a sense, iterable objects include both physical sequences and virtual se-
quences computed on demand.
Terminology in this topic tends to be a bit loose. The terms “iterable”
and “iterator” are sometimes used interchangeably to refer to an object
that supports iteration in general. For clarity, this book has a very strong
preference for using the term iterable to refer to an object that supports
the iter call, and iterator to refer to an object returned by an iterable on
iter that supports the next(I) call. Both these calls are defined ahead.
That convention is not universal in either the Python world or this book,
though; “iterator” is also sometimes used for tools that iterate. Chap-
ter 20 extends this category with the term “generator”—which refers to
objects that automatically support the iteration protocol, and hence are
iterable—even though all iterables generate results!
The Iteration Protocol: File Iterators
One of the easiest ways to understand the iteration protocol is to see how it works with
a built-in type such as the file. In this chapter, we’ll be using the following input file to
demonstrate:
>>> print(open('script2.py').read())
import sys
416 | Chapter 14: Iterations and Comprehensions](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-468-320.jpg)
![code, speed tends to increase. This is not an absolute truth, though, especially in Python
3.X; we’ll see timing techniques later in Chapter 21 for measuring the relative speed of
alternatives like these.1
Version skew note: In Python 2.X, the iteration method is named
X.next() instead of X.__next__(). For portability, a next(X) built-in
function is also available in both Python 3.X and 2.X (2.6 and later), and
calls X.__next__() in 3.X and X.next() in 2.X. Apart from method
names, iteration works the same in 2.X and 3.X in all other ways. In 2.6
and 2.7, simply use X.next() or next(X) for manual iterations instead of
3.X’s X.__next__(); prior to 2.6, use X.next() calls instead of next(X).
Manual Iteration: iter and next
To simplify manual iteration code, Python 3.X also provides a built-in function, next,
that automatically calls an object’s __next__ method. Per the preceding note, this call
also is supported on Python 2.X for portability. Given an iterator object X, the call
next(X) is the same as X.__next__() on 3.X (and X.next() on 2.X), but is noticeably
simpler and more version-neutral. With files, for instance, either form may be used:
>>> f = open('script2.py')
>>> f.__next__() # Call iteration method directly
'import sysn'
>>> f.__next__()
'print(sys.path)n'
>>> f = open('script2.py')
>>> next(f) # The next(f) built-in calls f.__next__() in 3.X
'import sysn'
>>> next(f) # next(f) => [3.X: f.__next__()], [2.X: f.next()]
'print(sys.path)n'
Technically, there is one more piece to the iteration protocol alluded to earlier. When
the for loop begins, it first obtains an iterator from the iterable object by passing it to
the iter built-in function; the object returned by iter in turn has the required next
method. The iter function internally runs the __iter__ method, much like next and
__next__.
1. Spoiler alert: the file iterator still appears to be slightly faster than readlines and at least 30% faster than
the while loop in both 2.7 and 3.3 on tests I’ve run with this chapter’s code on a 1,000-line file (while is
twice as slow on 2.7). The usual benchmarking caveats apply—this is true only for my Pythons, my
computer, and my test file, and Python 3.X complicates such analyses by rewriting I/O libraries to support
Unicode text and be less system-dependent. Chapter 21 covers tools and techniques you can use to time
these loop statements on your own.
Iterations: A First Look | 419](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-471-320.jpg)
![The full iteration protocol
As a more formal definition, Figure 14-1 sketches this full iteration protocol, used by
every iteration tool in Python, and supported by a wide variety of object types. It’s really
based on two objects, used in two distinct steps by iteration tools:
• The iterable object you request iteration for, whose __iter__ is run by iter
• The iterator object returned by the iterable that actually produces values during
the iteration, whose __next__ is run by next and raises StopIteration when finished
producing results
These steps are orchestrated automatically by iteration tools in most cases, but it helps
to understand these two objects’ roles. For example, in some cases these two objects
are the same when only a single scan is supported (e.g., files), and the iterator object is
often temporary, used internally by the iteration tool.
Moreover, some objects are both an iteration context tool (they iterate) and an iterable
object (their results are iterable)—including Chapter 20’s generator expressions, and
map and zip in Python 3.X. As we’ll see ahead, more tools become iterables in 3.X—
including map, zip, range, and some dictionary methods—to avoid constructing result
lists in memory all at once.
Figure 14-1. The Python iteration protocol, used by for loops, comprehensions, maps, and more, and
supported by files, lists, dictionaries, Chapter 20’s generators, and more. Some objects are both
iteration context and iterable object, such as generator expressions and 3.X’s flavors of some tools
(such as map and zip). Some objects are both iterable and iterator, returning themselves for the iter()
call, which is then a no-op.
In actual code, the protocol’s first step becomes obvious if we look at how for loops
internally process built-in sequence types such as lists:
>>> L = [1, 2, 3]
>>> I = iter(L) # Obtain an iterator object from an iterable
>>> I.__next__() # Call iterator's next to advance to next item
1
420 | Chapter 14: Iterations and Comprehensions](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-472-320.jpg)
![>>> I.__next__() # Or use I.next() in 2.X, next(I) in either line
2
>>> I.__next__()
3
>>> I.__next__()
...error text omitted...
StopIteration
This initial step is not required for files, because a file object is its own iterator. Because
they support just one iteration (they can’t seek backward to support multiple active
scans), files have their own __next__ method and do not need to return a different object
that does:
>>> f = open('script2.py')
>>> iter(f) is f
True
>>> iter(f) is f.__iter__()
True
>>> f.__next__()
'import sysn'
Lists and many other built-in objects, though, are not their own iterators because they
do support multiple open iterations—for example, there may be multiple iterations in
nested loops all at different positions. For such objects, we must call iter to start iter-
ating:
>>> L = [1, 2, 3]
>>> iter(L) is L
False
>>> L.__next__()
AttributeError: 'list' object has no attribute '__next__'
>>> I = iter(L)
>>> I.__next__()
1
>>> next(I) # Same as I.__next__()
2
Manual iteration
Although Python iteration tools call these functions automatically, we can use them to
apply the iteration protocol manually, too. The following interaction demonstrates the
equivalence between automatic and manual iteration:2
>>> L = [1, 2, 3]
>>>
>>> for X in L: # Automatic iteration
... print(X ** 2, end=' ') # Obtains iter, calls __next__, catches exceptions
...
1 4 9
2. Technically speaking, the for loop calls the internal equivalent of I.__next__, instead of the next(I) used
here, though there is rarely any difference between the two. Your manual iterations can generally use
either call scheme.
Iterations: A First Look | 421](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-473-320.jpg)
![>>> I = iter(L) # Manual iteration: what for loops usually do
>>> while True:
... try: # try statement catches exceptions
... X = next(I) # Or call I.__next__ in 3.X
... except StopIteration:
... break
... print(X ** 2, end=' ')
...
1 4 9
To understand this code, you need to know that try statements run an action and catch
exceptions that occur while the action runs (we met exceptions briefly in Chapter 11
but will explore them in depth in Part VII). I should also note that for loops and other
iteration contexts can sometimes work differently for user-defined classes, repeatedly
indexing an object instead of running the iteration protocol, but prefer the iteration
protocol if it’s used. We’ll defer that story until we study class operator overloading in
Chapter 30.
Other Built-in Type Iterables
Besides files and physical sequences like lists, other types have useful iterators as well.
The classic way to step through the keys of a dictionary, for example, is to request its
keys list explicitly:
>>> D = {'a':1, 'b':2, 'c':3}
>>> for key in D.keys():
... print(key, D[key])
...
a 1
b 2
c 3
In recent versions of Python, though, dictionaries are iterables with an iterator that
automatically returns one key at a time in an iteration context:
>>> I = iter(D)
>>> next(I)
'a'
>>> next(I)
'b'
>>> next(I)
'c'
>>> next(I)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
The net effect is that we no longer need to call the keys method to step through dic-
tionary keys—the for loop will use the iteration protocol to grab one key each time
through:
422 | Chapter 14: Iterations and Comprehensions](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-474-320.jpg)
![>>> for key in D:
... print(key, D[key])
...
a 1
b 2
c 3
We can’t delve into their details here, but other Python object types also support the
iteration protocol and thus may be used in for loops too. For instance, shelves (an
access-by-key filesystem for Python objects) and the results from os.popen (a tool for
reading the output of shell commands, which we met in the preceding chapter) are
iterable as well:
>>> import os
>>> P = os.popen('dir')
>>> P.__next__()
' Volume in drive C has no label.n'
>>> P.__next__()
' Volume Serial Number is D093-D1F7n'
>>> next(P)
TypeError: _wrap_close object is not an iterator
Notice that popen objects themselves support a P.next() method in Python 2.X. In 3.X,
they support the P.__next__() method, but not the next(P) built-in. Since the latter is
defined to call the former, this may seem unusual, though both calls work correctly if
we use the full iteration protocol employed automatically by for loops and other iter-
ation contexts, with its top-level iter call (this performs internal steps required to also
support next calls for this object):
>>> P = os.popen('dir')
>>> I = iter(P)
>>> next(I)
' Volume in drive C has no label.n'
>>> I.__next__()
' Volume Serial Number is D093-D1F7n'
Also in the systems domain, the standard directory walker in Python, os.walk, is sim-
ilarly iterable, but we’ll save an example until Chapter 20’s coverage of this tool’s basis
—generators and yield.
The iteration protocol also is the reason that we’ve had to wrap some results in a
list call to see their values all at once. Objects that are iterable return results one at a
time, not in a physical list:
>>> R = range(5)
>>> R # Ranges are iterables in 3.X
range(0, 5)
>>> I = iter(R) # Use iteration protocol to produce results
>>> next(I)
0
>>> next(I)
1
>>> list(range(5)) # Or use list to collect all results at once
[0, 1, 2, 3, 4]
Iterations: A First Look | 423](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-475-320.jpg)
![Note that the list call here is not required in 2.X (where range builds a real list), and
is not needed in 3.X for contexts where iteration happens automatically (such as within
for loops). It is needed for displaying values here in 3.X, though, and may also be
required when list-like behavior or multiple scans are required for objects that produce
results on demand in 2.X or 3.X (more on this ahead).
Now that you have a better understanding of this protocol, you should be able to see
how it explains why the enumerate tool introduced in the prior chapter works the way
it does:
>>> E = enumerate('spam') # enumerate is an iterable too
>>> E
<enumerate object at 0x00000000029B7678>
>>> I = iter(E)
>>> next(I) # Generate results with iteration protocol
(0, 's')
>>> next(I) # Or use list to force generation to run
(1, 'p')
>>> list(enumerate('spam'))
[(0, 's'), (1, 'p'), (2, 'a'), (3, 'm')]
We don’t normally see this machinery because for loops run it for us automatically to
step through results. In fact, everything that scans left to right in Python employs the
iteration protocol in the same way—including the topic of the next section.
List Comprehensions: A First Detailed Look
Now that we’ve seen how the iterati](https://image.slidesharecdn.com/learningpython-220619160042-176835c8/85/LearningPython-pdf-476-320.jpg)
LearningPython.pdf
- 3. FIFTH EDITION Learning Python Mark Lutz Beijing • Cambridge • Farnham • Köln • Sebastopol • Tokyo
- 4. Learning Python, Fifth Edition by Mark Lutz Copyright © 2013 Mark Lutz. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or [email protected]. Editor: Rachel Roumeliotis Production Editor: Christopher Hearse Copyeditor: Rachel Monaghan Proofreader: Julie Van Keuren Indexer: Lucie Haskins Cover Designer: Randy Comer Interior Designer: David Futato Illustrator: Rebecca Demarest June 2013: Fifth Edition. Revision History for the Fifth Edition: 2013-06-07 First release See http://oreilly.com/catalog/errata.csp?isbn=9781449355739 for release details. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Learning Python, 5th Edition, the image of a wood rat, and related trade dress are trademarks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trademark claim, the designations have been printed in caps or initial caps. While every precaution has been taken in the preparation of this book, the publisher and authors assume no responsibility for errors or omissions, or for damages resulting from the use of the information con- tained herein. ISBN: 978-1-449-35573-9 [QG] 1370970520
- 5. To Vera. You are my life.
- 7. Table of Contents Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxxiii Part I. Getting Started 1. A Python Q&A Session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Why Do People Use Python? 3 Software Quality 4 Developer Productivity 5 Is Python a “Scripting Language”? 5 OK, but What’s the Downside? 7 Who Uses Python Today? 9 What Can I Do with Python? 10 Systems Programming 11 GUIs 11 Internet Scripting 11 Component Integration 12 Database Programming 12 Rapid Prototyping 13 Numeric and Scientific Programming 13 And More: Gaming, Images, Data Mining, Robots, Excel... 14 How Is Python Developed and Supported? 15 Open Source Tradeoffs 15 What Are Python’s Technical Strengths? 16 It’s Object-Oriented and Functional 16 It’s Free 17 It’s Portable 17 It’s Powerful 18 It’s Mixable 19 It’s Relatively Easy to Use 19 It’s Relatively Easy to Learn 20 It’s Named After Monty Python 20 v
- 8. How Does Python Stack Up to Language X? 21 Chapter Summary 22 Test Your Knowledge: Quiz 23 Test Your Knowledge: Answers 23 2. How Python Runs Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Introducing the Python Interpreter 27 Program Execution 28 The Programmer’s View 28 Python’s View 30 Execution Model Variations 33 Python Implementation Alternatives 33 Execution Optimization Tools 37 Frozen Binaries 39 Future Possibilities? 40 Chapter Summary 40 Test Your Knowledge: Quiz 41 Test Your Knowledge: Answers 41 3. How You Run Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 The Interactive Prompt 43 Starting an Interactive Session 44 The System Path 45 New Windows Options in 3.3: PATH, Launcher 46 Where to Run: Code Directories 47 What Not to Type: Prompts and Comments 48 Running Code Interactively 49 Why the Interactive Prompt? 50 Usage Notes: The Interactive Prompt 52 System Command Lines and Files 54 A First Script 55 Running Files with Command Lines 56 Command-Line Usage Variations 57 Usage Notes: Command Lines and Files 58 Unix-Style Executable Scripts: #! 59 Unix Script Basics 59 The Unix env Lookup Trick 60 The Python 3.3 Windows Launcher: #! Comes to Windows 60 Clicking File Icons 62 Icon-Click Basics 62 Clicking Icons on Windows 63 The input Trick on Windows 63 Other Icon-Click Limitations 66 vi | Table of Contents
- 9. Module Imports and Reloads 66 Import and Reload Basics 66 The Grander Module Story: Attributes 68 Usage Notes: import and reload 71 Using exec to Run Module Files 72 The IDLE User Interface 73 IDLE Startup Details 74 IDLE Basic Usage 75 IDLE Usability Features 76 Advanced IDLE Tools 77 Usage Notes: IDLE 78 Other IDEs 79 Other Launch Options 81 Embedding Calls 81 Frozen Binary Executables 82 Text Editor Launch Options 82 Still Other Launch Options 82 Future Possibilities? 83 Which Option Should I Use? 83 Chapter Summary 85 Test Your Knowledge: Quiz 85 Test Your Knowledge: Answers 86 Test Your Knowledge: Part I Exercises 87 Part II. Types and Operations 4. Introducing Python Object Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 The Python Conceptual Hierarchy 93 Why Use Built-in Types? 94 Python’s Core Data Types 95 Numbers 97 Strings 99 Sequence Operations 99 Immutability 101 Type-Specific Methods 102 Getting Help 104 Other Ways to Code Strings 105 Unicode Strings 106 Pattern Matching 108 Lists 109 Sequence Operations 109 Type-Specific Operations 109 Table of Contents | vii
- 10. Bounds Checking 110 Nesting 110 Comprehensions 111 Dictionaries 113 Mapping Operations 114 Nesting Revisited 115 Missing Keys: if Tests 116 Sorting Keys: for Loops 118 Iteration and Optimization 120 Tuples 121 Why Tuples? 122 Files 122 Binary Bytes Files 123 Unicode Text Files 124 Other File-Like Tools 126 Other Core Types 126 How to Break Your Code’s Flexibility 128 User-Defined Classes 129 And Everything Else 130 Chapter Summary 130 Test Your Knowledge: Quiz 131 Test Your Knowledge: Answers 131 5. Numeric Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Numeric Type Basics 133 Numeric Literals 134 Built-in Numeric Tools 136 Python Expression Operators 136 Numbers in Action 141 Variables and Basic Expressions 141 Numeric Display Formats 143 Comparisons: Normal and Chained 144 Division: Classic, Floor, and True 146 Integer Precision 150 Complex Numbers 151 Hex, Octal, Binary: Literals and Conversions 151 Bitwise Operations 153 Other Built-in Numeric Tools 155 Other Numeric Types 157 Decimal Type 157 Fraction Type 160 Sets 163 Booleans 171 viii | Table of Contents
- 11. Numeric Extensions 172 Chapter Summary 172 Test Your Knowledge: Quiz 173 Test Your Knowledge: Answers 173 6. The Dynamic Typing Interlude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 The Case of the Missing Declaration Statements 175 Variables, Objects, and References 176 Types Live with Objects, Not Variables 177 Objects Are Garbage-Collected 178 Shared References 180 Shared References and In-Place Changes 181 Shared References and Equality 183 Dynamic Typing Is Everywhere 185 Chapter Summary 186 Test Your Knowledge: Quiz 186 Test Your Knowledge: Answers 186 7. String Fundamentals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 This Chapter’s Scope 189 Unicode: The Short Story 189 String Basics 190 String Literals 192 Single- and Double-Quoted Strings Are the Same 193 Escape Sequences Represent Special Characters 193 Raw Strings Suppress Escapes 196 Triple Quotes Code Multiline Block Strings 198 Strings in Action 200 Basic Operations 200 Indexing and Slicing 201 String Conversion Tools 205 Changing Strings I 208 String Methods 209 Method Call Syntax 209 Methods of Strings 210 String Method Examples: Changing Strings II 211 String Method Examples: Parsing Text 213 Other Common String Methods in Action 214 The Original string Module’s Functions (Gone in 3.X) 215 String Formatting Expressions 216 Formatting Expression Basics 217 Advanced Formatting Expression Syntax 218 Advanced Formatting Expression Examples 220 Table of Contents | ix
- 12. Dictionary-Based Formatting Expressions 221 String Formatting Method Calls 222 Formatting Method Basics 222 Adding Keys, Attributes, and Offsets 223 Advanced Formatting Method Syntax 224 Advanced Formatting Method Examples 225 Comparison to the % Formatting Expression 227 Why the Format Method? 230 General Type Categories 235 Types Share Operation Sets by Categories 235 Mutable Types Can Be Changed in Place 236 Chapter Summary 237 Test Your Knowledge: Quiz 237 Test Your Knowledge: Answers 237 8. Lists and Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Lists 239 Lists in Action 242 Basic List Operations 242 List Iteration and Comprehensions 242 Indexing, Slicing, and Matrixes 243 Changing Lists in Place 244 Dictionaries 250 Dictionaries in Action 252 Basic Dictionary Operations 253 Changing Dictionaries in Place 254 More Dictionary Methods 254 Example: Movie Database 256 Dictionary Usage Notes 258 Other Ways to Make Dictionaries 262 Dictionary Changes in Python 3.X and 2.7 264 Chapter Summary 271 Test Your Knowledge: Quiz 272 Test Your Knowledge: Answers 272 9. Tuples, Files, and Everything Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 Tuples 276 Tuples in Action 277 Why Lists and Tuples? 279 Records Revisited: Named Tuples 280 Files 282 Opening Files 283 Using Files 284 x | Table of Contents
- 13. Files in Action 285 Text and Binary Files: The Short Story 287 Storing Python Objects in Files: Conversions 288 Storing Native Python Objects: pickle 290 Storing Python Objects in JSON Format 291 Storing Packed Binary Data: struct 293 File Context Managers 294 Other File Tools 294 Core Types Review and Summary 295 Object Flexibility 297 References Versus Copies 297 Comparisons, Equality, and Truth 300 The Meaning of True and False in Python 304 Python’s Type Hierarchies 306 Type Objects 306 Other Types in Python 308 Built-in Type Gotchas 308 Assignment Creates References, Not Copies 308 Repetition Adds One Level Deep 309 Beware of Cyclic Data Structures 310 Immutable Types Can’t Be Changed in Place 311 Chapter Summary 311 Test Your Knowledge: Quiz 311 Test Your Knowledge: Answers 312 Test Your Knowledge: Part II Exercises 313 Part III. Statements and Syntax 10. Introducing Python Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 The Python Conceptual Hierarchy Revisited 319 Python’s Statements 320 A Tale of Two ifs 322 What Python Adds 322 What Python Removes 323 Why Indentation Syntax? 324 A Few Special Cases 327 A Quick Example: Interactive Loops 329 A Simple Interactive Loop 329 Doing Math on User Inputs 331 Handling Errors by Testing Inputs 332 Handling Errors with try Statements 333 Nesting Code Three Levels Deep 335 Table of Contents | xi
- 14. Chapter Summary 336 Test Your Knowledge: Quiz 336 Test Your Knowledge: Answers 336 11. Assignments, Expressions, and Prints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 Assignment Statements 339 Assignment Statement Forms 340 Sequence Assignments 341 Extended Sequence Unpacking in Python 3.X 344 Multiple-Target Assignments 348 Augmented Assignments 350 Variable Name Rules 352 Expression Statements 356 Expression Statements and In-Place Changes 357 Print Operations 358 The Python 3.X print Function 359 The Python 2.X print Statement 361 Print Stream Redirection 363 Version-Neutral Printing 366 Chapter Summary 369 Test Your Knowledge: Quiz 370 Test Your Knowledge: Answers 370 12. if Tests and Syntax Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 if Statements 371 General Format 371 Basic Examples 372 Multiway Branching 372 Python Syntax Revisited 375 Block Delimiters: Indentation Rules 376 Statement Delimiters: Lines and Continuations 378 A Few Special Cases 379 Truth Values and Boolean Tests 380 The if/else Ternary Expression 382 Chapter Summary 385 Test Your Knowledge: Quiz 385 Test Your Knowledge: Answers 386 13. while and for Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 while Loops 387 General Format 388 Examples 388 break, continue, pass, and the Loop else 389 xii | Table of Contents
- 15. General Loop Format 389 pass 390 continue 391 break 391 Loop else 392 for Loops 395 General Format 395 Examples 395 Loop Coding Techniques 402 Counter Loops: range 402 Sequence Scans: while and range Versus for 403 Sequence Shufflers: range and len 404 Nonexhaustive Traversals: range Versus Slices 405 Changing Lists: range Versus Comprehensions 406 Parallel Traversals: zip and map 407 Generating Both Offsets and Items: enumerate 410 Chapter Summary 413 Test Your Knowledge: Quiz 414 Test Your Knowledge: Answers 414 14. Iterations and Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415 Iterations: A First Look 416 The Iteration Protocol: File Iterators 416 Manual Iteration: iter and next 419 Other Built-in Type Iterables 422 List Comprehensions: A First Detailed Look 424 List Comprehension Basics 425 Using List Comprehensions on Files 426 Extended List Comprehension Syntax 427 Other Iteration Contexts 429 New Iterables in Python 3.X 434 Impacts on 2.X Code: Pros and Cons 434 The range Iterable 435 The map, zip, and filter Iterables 436 Multiple Versus Single Pass Iterators 438 Dictionary View Iterables 439 Other Iteration Topics 440 Chapter Summary 441 Test Your Knowledge: Quiz 441 Test Your Knowledge: Answers 441 15. The Documentation Interlude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 Python Documentation Sources 443 Table of Contents | xiii
- 16. # Comments 444 The dir Function 444 Docstrings: __doc__ 446 PyDoc: The help Function 449 PyDoc: HTML Reports 452 Beyond docstrings: Sphinx 461 The Standard Manual Set 461 Web Resources 462 Published Books 463 Common Coding Gotchas 463 Chapter Summary 465 Test Your Knowledge: Quiz 466 Test Your Knowledge: Answers 466 Test Your Knowledge: Part III Exercises 467 Part IV. Functions and Generators 16. Function Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473 Why Use Functions? 474 Coding Functions 475 def Statements 476 def Executes at Runtime 477 A First Example: Definitions and Calls 478 Definition 478 Calls 478 Polymorphism in Python 479 A Second Example: Intersecting Sequences 480 Definition 481 Calls 481 Polymorphism Revisited 482 Local Variables 483 Chapter Summary 483 Test Your Knowledge: Quiz 483 Test Your Knowledge: Answers 484 17. Scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485 Python Scope Basics 485 Scope Details 486 Name Resolution: The LEGB Rule 488 Scope Example 490 The Built-in Scope 491 The global Statement 494 xiv | Table of Contents
- 17. Program Design: Minimize Global Variables 495 Program Design: Minimize Cross-File Changes 497 Other Ways to Access Globals 498 Scopes and Nested Functions 499 Nested Scope Details 500 Nested Scope Examples 500 Factory Functions: Closures 501 Retaining Enclosing Scope State with Defaults 504 The nonlocal Statement in 3.X 508 nonlocal Basics 508 nonlocal in Action 509 Why nonlocal? State Retention Options 512 State with nonlocal: 3.X only 512 State with Globals: A Single Copy Only 513 State with Classes: Explicit Attributes (Preview) 513 State with Function Attributes: 3.X and 2.X 515 Chapter Summary 519 Test Your Knowledge: Quiz 519 Test Your Knowledge: Answers 520 18. Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523 Argument-Passing Basics 523 Arguments and Shared References 524 Avoiding Mutable Argument Changes 526 Simulating Output Parameters and Multiple Results 527 Special Argument-Matching Modes 528 Argument Matching Basics 529 Argument Matching Syntax 530 The Gritty Details 531 Keyword and Default Examples 532 Arbitrary Arguments Examples 534 Python 3.X Keyword-Only Arguments 539 The min Wakeup Call! 542 Full Credit 542 Bonus Points 544 The Punch Line... 544 Generalized Set Functions 545 Emulating the Python 3.X print Function 547 Using Keyword-Only Arguments 548 Chapter Summary 550 Test Your Knowledge: Quiz 551 Test Your Knowledge: Answers 552 Table of Contents | xv
- 18. 19. Advanced Function Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553 Function Design Concepts 553 Recursive Functions 555 Summation with Recursion 555 Coding Alternatives 556 Loop Statements Versus Recursion 557 Handling Arbitrary Structures 558 Function Objects: Attributes and Annotations 562 Indirect Function Calls: “First Class” Objects 562 Function Introspection 563 Function Attributes 564 Function Annotations in 3.X 565 Anonymous Functions: lambda 567 lambda Basics 568 Why Use lambda? 569 How (Not) to Obfuscate Your Python Code 571 Scopes: lambdas Can Be Nested Too 572 Functional Programming Tools 574 Mapping Functions over Iterables: map 574 Selecting Items in Iterables: filter 576 Combining Items in Iterables: reduce 576 Chapter Summary 578 Test Your Knowledge: Quiz 578 Test Your Knowledge: Answers 578 20. Comprehensions and Generations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581 List Comprehensions and Functional Tools 581 List Comprehensions Versus map 582 Adding Tests and Nested Loops: filter 583 Example: List Comprehensions and Matrixes 586 Don’t Abuse List Comprehensions: KISS 588 Generator Functions and Expressions 591 Generator Functions: yield Versus return 592 Generator Expressions: Iterables Meet Comprehensions 597 Generator Functions Versus Generator Expressions 602 Generators Are Single-Iteration Objects 604 Generation in Built-in Types, Tools, and Classes 606 Example: Generating Scrambled Sequences 609 Don’t Abuse Generators: EIBTI 614 Example: Emulating zip and map with Iteration Tools 617 Comprehension Syntax Summary 622 Scopes and Comprehension Variables 623 Comprehending Set and Dictionary Comprehensions 624 xvi | Table of Contents
- 19. Extended Comprehension Syntax for Sets and Dictionaries 625 Chapter Summary 626 Test Your Knowledge: Quiz 626 Test Your Knowledge: Answers 626 21. The Benchmarking Interlude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629 Timing Iteration Alternatives 629 Timing Module: Homegrown 630 Timing Script 634 Timing Results 635 Timing Module Alternatives 638 Other Suggestions 642 Timing Iterations and Pythons with timeit 642 Basic timeit Usage 643 Benchmark Module and Script: timeit 647 Benchmark Script Results 649 More Fun with Benchmarks 651 Other Benchmarking Topics: pystones 656 Function Gotchas 656 Local Names Are Detected Statically 657 Defaults and Mutable Objects 658 Functions Without returns 660 Miscellaneous Function Gotchas 661 Chapter Summary 661 Test Your Knowledge: Quiz 662 Test Your Knowledge: Answers 662 Test Your Knowledge: Part IV Exercises 663 Part V. Modules and Packages 22. Modules: The Big Picture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669 Why Use Modules? 669 Python Program Architecture 670 How to Structure a Program 671 Imports and Attributes 671 Standard Library Modules 673 How Imports Work 674 1. Find It 674 2. Compile It (Maybe) 675 3. Run It 675 Byte Code Files: __pycache__ in Python 3.2+ 676 Byte Code File Models in Action 677 Table of Contents | xvii
- 20. The Module Search Path 678 Configuring the Search Path 681 Search Path Variations 681 The sys.path List 681 Module File Selection 682 Chapter Summary 685 Test Your Knowledge: Quiz 685 Test Your Knowledge: Answers 685 23. Module Coding Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687 Module Creation 687 Module Filenames 687 Other Kinds of Modules 688 Module Usage 688 The import Statement 689 The from Statement 689 The from * Statement 689 Imports Happen Only Once 690 import and from Are Assignments 691 import and from Equivalence 692 Potential Pitfalls of the from Statement 693 Module Namespaces 694 Files Generate Namespaces 695 Namespace Dictionaries: __dict__ 696 Attribute Name Qualification 697 Imports Versus Scopes 698 Namespace Nesting 699 Reloading Modules 700 reload Basics 701 reload Example 702 Chapter Summary 703 Test Your Knowledge: Quiz 704 Test Your Knowledge: Answers 704 24. Module Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707 Package Import Basics 708 Packages and Search Path Settings 708 Package __init__.py Files 709 Package Import Example 711 from Versus import with Packages 713 Why Use Package Imports? 713 A Tale of Three Systems 714 Package Relative Imports 717 xviii | Table of Contents
- 21. Changes in Python 3.X 718 Relative Import Basics 718 Why Relative Imports? 720 The Scope of Relative Imports 722 Module Lookup Rules Summary 723 Relative Imports in Action 723 Pitfalls of Package-Relative Imports: Mixed Use 729 Python 3.3 Namespace Packages 734 Namespace Package Semantics 735 Impacts on Regular Packages: Optional __init__.py 736 Namespace Packages in Action 737 Namespace Package Nesting 738 Files Still Have Precedence over Directories 740 Chapter Summary 742 Test Your Knowledge: Quiz 742 Test Your Knowledge: Answers 742 25. Advanced Module Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745 Module Design Concepts 745 Data Hiding in Modules 747 Minimizing from * Damage: _X and __all__ 747 Enabling Future Language Features: __future__ 748 Mixed Usage Modes: __name__ and __main__ 749 Unit Tests with __name__ 750 Example: Dual Mode Code 751 Currency Symbols: Unicode in Action 754 Docstrings: Module Documentation at Work 756 Changing the Module Search Path 756 The as Extension for import and from 758 Example: Modules Are Objects 759 Importing Modules by Name String 761 Running Code Strings 762 Direct Calls: Two Options 762 Example: Transitive Module Reloads 763 A Recursive Reloader 764 Alternative Codings 767 Module Gotchas 770 Module Name Clashes: Package and Package-Relative Imports 771 Statement Order Matters in Top-Level Code 771 from Copies Names but Doesn’t Link 772 from * Can Obscure the Meaning of Variables 773 reload May Not Impact from Imports 773 reload, from, and Interactive Testing 774 Table of Contents | xix
- 22. Recursive from Imports May Not Work 775 Chapter Summary 776 Test Your Knowledge: Quiz 777 Test Your Knowledge: Answers 777 Test Your Knowledge: Part V Exercises 778 Part VI. Classes and OOP 26. OOP: The Big Picture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783 Why Use Classes? 784 OOP from 30,000 Feet 785 Attribute Inheritance Search 785 Classes and Instances 788 Method Calls 788 Coding Class Trees 789 Operator Overloading 791 OOP Is About Code Reuse 792 Chapter Summary 795 Test Your Knowledge: Quiz 795 Test Your Knowledge: Answers 795 27. Class Coding Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797 Classes Generate Multiple Instance Objects 797 Class Objects Provide Default Behavior 798 Instance Objects Are Concrete Items 798 A First Example 799 Classes Are Customized by Inheritance 801 A Second Example 802 Classes Are Attributes in Modules 804 Classes Can Intercept Python Operators 805 A Third Example 806 Why Use Operator Overloading? 808 The World’s Simplest Python Class 809 Records Revisited: Classes Versus Dictionaries 812 Chapter Summary 814 Test Your Knowledge: Quiz 815 Test Your Knowledge: Answers 815 28. A More Realistic Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817 Step 1: Making Instances 818 Coding Constructors 818 Testing As You Go 819 xx | Table of Contents
- 23. Using Code Two Ways 820 Step 2: Adding Behavior Methods 822 Coding Methods 824 Step 3: Operator Overloading 826 Providing Print Displays 826 Step 4: Customizing Behavior by Subclassing 828 Coding Subclasses 828 Augmenting Methods: The Bad Way 829 Augmenting Methods: The Good Way 829 Polymorphism in Action 832 Inherit, Customize, and Extend 833 OOP: The Big Idea 833 Step 5: Customizing Constructors, Too 834 OOP Is Simpler Than You May Think 836 Other Ways to Combine Classes 836 Step 6: Using Introspection Tools 840 Special Class Attributes 840 A Generic Display Tool 842 Instance Versus Class Attributes 843 Name Considerations in Tool Classes 844 Our Classes’ Final Form 845 Step 7 (Final): Storing Objects in a Database 847 Pickles and Shelves 847 Storing Objects on a Shelve Database 848 Exploring Shelves Interactively 849 Updating Objects on a Shelve 851 Future Directions 853 Chapter Summary 855 Test Your Knowledge: Quiz 855 Test Your Knowledge: Answers 856 29. Class Coding Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859 The class Statement 859 General Form 860 Example 860 Methods 862 Method Example 863 Calling Superclass Constructors 864 Other Method Call Possibilities 864 Inheritance 865 Attribute Tree Construction 865 Specializing Inherited Methods 866 Class Interface Techniques 867 Table of Contents | xxi
- 24. Abstract Superclasses 869 Namespaces: The Conclusion 872 Simple Names: Global Unless Assigned 872 Attribute Names: Object Namespaces 872 The “Zen” of Namespaces: Assignments Classify Names 873 Nested Classes: The LEGB Scopes Rule Revisited 875 Namespace Dictionaries: Review 878 Namespace Links: A Tree Climber 880 Documentation Strings Revisited 882 Classes Versus Modules 884 Chapter Summary 884 Test Your Knowledge: Quiz 884 Test Your Knowledge: Answers 885 30. Operator Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887 The Basics 887 Constructors and Expressions: __init__ and __sub__ 888 Common Operator Overloading Methods 888 Indexing and Slicing: __getitem__ and __setitem__ 890 Intercepting Slices 891 Slicing and Indexing in Python 2.X 893 But 3.X’s __index__ Is Not Indexing! 894 Index Iteration: __getitem__ 894 Iterable Objects: __iter__ and __next__ 895 User-Defined Iterables 896 Multiple Iterators on One Object 899 Coding Alternative: __iter__ plus yield 902 Membership: __contains__, __iter__, and __getitem__ 906 Attribute Access: __getattr__ and __setattr__ 909 Attribute Reference 909 Attribute Assignment and Deletion 910 Other Attribute Management Tools 912 Emulating Privacy for Instance Attributes: Part 1 912 String Representation: __repr__ and __str__ 913 Why Two Display Methods? 914 Display Usage Notes 916 Right-Side and In-Place Uses: __radd__ and __iadd__ 917 Right-Side Addition 917 In-Place Addition 920 Call Expressions: __call__ 921 Function Interfaces and Callback-Based Code 923 Comparisons: __lt__, __gt__, and Others 925 The __cmp__ Method in Python 2.X 926 xxii | Table of Contents
- 25. Boolean Tests: __bool__ and __len__ 927 Boolean Methods in Python 2.X 928 Object Destruction: __del__ 929 Destructor Usage Notes 930 Chapter Summary 931 Test Your Knowledge: Quiz 931 Test Your Knowledge: Answers 931 31. Designing with Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933 Python and OOP 933 Polymorphism Means Interfaces, Not Call Signatures 934 OOP and Inheritance: “Is-a” Relationships 935 OOP and Composition: “Has-a” Relationships 937 Stream Processors Revisited 938 OOP and Delegation: “Wrapper” Proxy Objects 942 Pseudoprivate Class Attributes 944 Name Mangling Overview 945 Why Use Pseudoprivate Attributes? 945 Methods Are Objects: Bound or Unbound 948 Unbound Methods Are Functions in 3.X 950 Bound Methods and Other Callable Objects 951 Classes Are Objects: Generic Object Factories 954 Why Factories? 955 Multiple Inheritance: “Mix-in” Classes 956 Coding Mix-in Display Classes 957 Other Design-Related Topics 977 Chapter Summary 977 Test Your Knowledge: Quiz 978 Test Your Knowledge: Answers 978 32. Advanced Class Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979 Extending Built-in Types 980 Extending Types by Embedding 980 Extending Types by Subclassing 981 The “New Style” Class Model 983 Just How New Is New-Style? 984 New-Style Class Changes 985 Attribute Fetch for Built-ins Skips Instances 987 Type Model Changes 992 All Classes Derive from “object” 995 Diamond Inheritance Change 997 More on the MRO: Method Resolution Order 1001 Example: Mapping Attributes to Inheritance Sources 1004 Table of Contents | xxiii
- 26. New-Style Class Extensions 1010 Slots: Attribute Declarations 1010 Properties: Attribute Accessors 1020 __getattribute__ and Descriptors: Attribute Tools 1023 Other Class Changes and Extensions 1023 Static and Class Methods 1024 Why the Special Methods? 1024 Static Methods in 2.X and 3.X 1025 Static Method Alternatives 1027 Using Static and Class Methods 1028 Counting Instances with Static Methods 1030 Counting Instances with Class Methods 1031 Decorators and Metaclasses: Part 1 1034 Function Decorator Basics 1035 A First Look at User-Defined Function Decorators 1037 A First Look at Class Decorators and Metaclasses 1038 For More Details 1040 The super Built-in Function: For Better or Worse? 1041 The Great super Debate 1041 Traditional Superclass Call Form: Portable, General 1042 Basic super Usage and Its Tradeoffs 1043 The super Upsides: Tree Changes and Dispatch 1049 Runtime Class Changes and super 1049 Cooperative Multiple Inheritance Method Dispatch 1050 The super Summary 1062 Class Gotchas 1064 Changing Class Attributes Can Have Side Effects 1064 Changing Mutable Class Attributes Can Have Side Effects, Too 1065 Multiple Inheritance: Order Matters 1066 Scopes in Methods and Classes 1068 Miscellaneous Class Gotchas 1069 KISS Revisited: “Overwrapping-itis” 1070 Chapter Summary 1070 Test Your Knowledge: Quiz 1071 Test Your Knowledge: Answers 1071 Test Your Knowledge: Part VI Exercises 1072 Part VII. Exceptions and Tools 33. Exception Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081 Why Use Exceptions? 1081 Exception Roles 1082 xxiv | Table of Contents
- 27. Exceptions: The Short Story 1083 Default Exception Handler 1083 Catching Exceptions 1084 Raising Exceptions 1085 User-Defined Exceptions 1086 Termination Actions 1087 Chapter Summary 1089 Test Your Knowledge: Quiz 1090 Test Your Knowledge: Answers 1090 34. Exception Coding Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1093 The try/except/else Statement 1093 How try Statements Work 1094 try Statement Clauses 1095 The try else Clause 1098 Example: Default Behavior 1098 Example: Catching Built-in Exceptions 1100 The try/finally Statement 1100 Example: Coding Termination Actions with try/finally 1101 Unified try/except/finally 1102 Unified try Statement Syntax 1104 Combining finally and except by Nesting 1104 Unified try Example 1105 The raise Statement 1106 Raising Exceptions 1107 Scopes and try except Variables 1108 Propagating Exceptions with raise 1110 Python 3.X Exception Chaining: raise from 1110 The assert Statement 1112 Example: Trapping Constraints (but Not Errors!) 1113 with/as Context Managers 1114 Basic Usage 1114 The Context Management Protocol 1116 Multiple Context Managers in 3.1, 2.7, and Later 1118 Chapter Summary 1119 Test Your Knowledge: Quiz 1120 Test Your Knowledge: Answers 1120 35. Exception Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1123 Exceptions: Back to the Future 1124 String Exceptions Are Right Out! 1124 Class-Based Exceptions 1125 Coding Exceptions Classes 1126 Table of Contents | xxv
- 28. Why Exception Hierarchies? 1128 Built-in Exception Classes 1131 Built-in Exception Categories 1132 Default Printing and State 1133 Custom Print Displays 1135 Custom Data and Behavior 1136 Providing Exception Details 1136 Providing Exception Methods 1137 Chapter Summary 1139 Test Your Knowledge: Quiz 1139 Test Your Knowledge: Answers 1139 36. Designing with Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1141 Nesting Exception Handlers 1141 Example: Control-Flow Nesting 1143 Example: Syntactic Nesting 1143 Exception Idioms 1145 Breaking Out of Multiple Nested Loops: “go to” 1145 Exceptions Aren’t Always Errors 1146 Functions Can Signal Conditions with raise 1147 Closing Files and Server Connections 1148 Debugging with Outer try Statements 1149 Running In-Process Tests 1149 More on sys.exc_info 1150 Displaying Errors and Tracebacks 1151 Exception Design Tips and Gotchas 1152 What Should Be Wrapped 1152 Catching Too Much: Avoid Empty except and Exception 1153 Catching Too Little: Use Class-Based Categories 1155 Core Language Summary 1155 The Python Toolset 1156 Development Tools for Larger Projects 1157 Chapter Summary 1160 Test Your Knowledge: Quiz 1161 Test Your Knowledge: Answers 1161 Test Your Knowledge: Part VII Exercises 1161 Part VIII. Advanced Topics 37. Unicode and Byte Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165 String Changes in 3.X 1166 String Basics 1167 xxvi | Table of Contents
- 29. Character Encoding Schemes 1167 How Python Stores Strings in Memory 1170 Python’s String Types 1171 Text and Binary Files 1173 Coding Basic Strings 1174 Python 3.X String Literals 1175 Python 2.X String Literals 1176 String Type Conversions 1177 Coding Unicode Strings 1178 Coding ASCII Text 1178 Coding Non-ASCII Text 1179 Encoding and Decoding Non-ASCII text 1180 Other Encoding Schemes 1181 Byte String Literals: Encoded Text 1183 Converting Encodings 1184 Coding Unicode Strings in Python 2.X 1185 Source File Character Set Encoding Declarations 1187 Using 3.X bytes Objects 1189 Method Calls 1189 Sequence Operations 1190 Other Ways to Make bytes Objects 1191 Mixing String Types 1192 Using 3.X/2.6+ bytearray Objects 1192 bytearrays in Action 1193 Python 3.X String Types Summary 1195 Using Text and Binary Files 1195 Text File Basics 1196 Text and Binary Modes in 2.X and 3.X 1197 Type and Content Mismatches in 3.X 1198 Using Unicode Files 1199 Reading and Writing Unicode in 3.X 1199 Handling the BOM in 3.X 1201 Unicode Files in 2.X 1204 Unicode Filenames and Streams 1205 Other String Tool Changes in 3.X 1206 The re Pattern-Matching Module 1206 The struct Binary Data Module 1207 The pickle Object Serialization Module 1209 XML Parsing Tools 1211 Chapter Summary 1215 Test Your Knowledge: Quiz 1215 Test Your Knowledge: Answers 1216 Table of Contents | xxvii
- 30. 38. Managed Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1219 Why Manage Attributes? 1219 Inserting Code to Run on Attribute Access 1220 Properties 1221 The Basics 1222 A First Example 1222 Computed Attributes 1224 Coding Properties with Decorators 1224 Descriptors 1226 The Basics 1227 A First Example 1229 Computed Attributes 1231 Using State Information in Descriptors 1232 How Properties and Descriptors Relate 1236 __getattr__ and __getattribute__ 1237 The Basics 1238 A First Example 1241 Computed Attributes 1243 __getattr__ and __getattribute__ Compared 1245 Management Techniques Compared 1246 Intercepting Built-in Operation Attributes 1249 Example: Attribute Validations 1256 Using Properties to Validate 1256 Using Descriptors to Validate 1259 Using __getattr__ to Validate 1263 Using __getattribute__ to Validate 1265 Chapter Summary 1266 Test Your Knowledge: Quiz 1266 Test Your Knowledge: Answers 1267 39. Decorators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1269 What’s a Decorator? 1269 Managing Calls and Instances 1270 Managing Functions and Classes 1270 Using and Defining Decorators 1271 Why Decorators? 1271 The Basics 1273 Function Decorators 1273 Class Decorators 1277 Decorator Nesting 1279 Decorator Arguments 1281 Decorators Manage Functions and Classes, Too 1282 Coding Function Decorators 1283 xxviii | Table of Contents
- 31. Tracing Calls 1283 Decorator State Retention Options 1285 Class Blunders I: Decorating Methods 1289 Timing Calls 1295 Adding Decorator Arguments 1298 Coding Class Decorators 1301 Singleton Classes 1301 Tracing Object Interfaces 1303 Class Blunders II: Retaining Multiple Instances 1308 Decorators Versus Manager Functions 1309 Why Decorators? (Revisited) 1310 Managing Functions and Classes Directly 1312 Example: “Private” and “Public” Attributes 1314 Implementing Private Attributes 1314 Implementation Details I 1317 Generalizing for Public Declarations, Too 1318 Implementation Details II 1320 Open Issues 1321 Python Isn’t About Control 1329 Example: Validating Function Arguments 1330 The Goal 1330 A Basic Range-Testing Decorator for Positional Arguments 1331 Generalizing for Keywords and Defaults, Too 1333 Implementation Details 1336 Open Issues 1338 Decorator Arguments Versus Function Annotations 1340 Other Applications: Type Testing (If You Insist!) 1342 Chapter Summary 1343 Test Your Knowledge: Quiz 1344 Test Your Knowledge: Answers 1345 40. Metaclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1355 To Metaclass or Not to Metaclass 1356 Increasing Levels of “Magic” 1357 A Language of Hooks 1358 The Downside of “Helper” Functions 1359 Metaclasses Versus Class Decorators: Round 1 1361 The Metaclass Model 1364 Classes Are Instances of type 1364 Metaclasses Are Subclasses of Type 1366 Class Statement Protocol 1367 Declaring Metaclasses 1368 Declaration in 3.X 1369 Table of Contents | xxix
- 32. Declaration in 2.X 1369 Metaclass Dispatch in Both 3.X and 2.X 1370 Coding Metaclasses 1370 A Basic Metaclass 1371 Customizing Construction and Initialization 1372 Other Metaclass Coding Techniques 1373 Inheritance and Instance 1378 Metaclass Versus Superclass 1381 Inheritance: The Full Story 1382 Metaclass Methods 1388 Metaclass Methods Versus Class Methods 1389 Operator Overloading in Metaclass Methods 1390 Example: Adding Methods to Classes 1391 Manual Augmentation 1391 Metaclass-Based Augmentation 1393 Metaclasses Versus Class Decorators: Round 2 1394 Example: Applying Decorators to Methods 1400 Tracing with Decoration Manually 1400 Tracing with Metaclasses and Decorators 1401 Applying Any Decorator to Methods 1403 Metaclasses Versus Class Decorators: Round 3 (and Last) 1404 Chapter Summary 1407 Test Your Knowledge: Quiz 1407 Test Your Knowledge: Answers 1408 41. All Good Things . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1409 The Python Paradox 1409 On “Optional” Language Features 1410 Against Disquieting Improvements 1411 Complexity Versus Power 1412 Simplicity Versus Elitism 1412 Closing Thoughts 1413 Where to Go From Here 1414 Encore: Print Your Own Completion Certificate! 1414 Part IX. Appendixes A. Installation and Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1421 Installing the Python Interpreter 1421 Is Python Already Present? 1421 Where to Get Python 1422 Installation Steps 1423 xxx | Table of Contents
- 33. Configuring Python 1427 Python Environment Variables 1427 How to Set Configuration Options 1429 Python Command-Line Arguments 1432 Python 3.3 Windows Launcher Command Lines 1435 For More Help 1436 B. The Python 3.3 Windows Launcher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1437 The Unix Legacy 1437 The Windows Legacy 1438 Introducing the New Windows Launcher 1439 A Windows Launcher Tutorial 1441 Step 1: Using Version Directives in Files 1441 Step 2: Using Command-Line Version Switches 1444 Step 3: Using and Changing Defaults 1445 Pitfalls of the New Windows Launcher 1447 Pitfall 1: Unrecognized Unix !# Lines Fail 1447 Pitfall 2: The Launcher Defaults to 2.X 1448 Pitfall 3: The New PATH Extension Option 1449 Conclusions: A Net Win for Windows 1450 C. Python Changes and This Book . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1451 Major 2.X/3.X Differences 1451 3.X Differences 1452 3.X-Only Extensions 1453 General Remarks: 3.X Changes 1454 Changes in Libraries and Tools 1454 Migrating to 3.X 1455 Fifth Edition Python Changes: 2.7, 3.2, 3.3 1456 Changes in Python 2.7 1456 Changes in Python 3.3 1457 Changes in Python 3.2 1458 Fourth Edition Python Changes: 2.6, 3.0, 3.1 1458 Changes in Python 3.1 1458 Changes in Python 3.0 and 2.6 1459 Specific Language Removals in 3.0 1460 Third Edition Python Changes: 2.3, 2.4, 2.5 1462 Earlier and Later Python Changes 1463 D. Solutions to End-of-Part Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1465 Part I, Getting Started 1465 Part II, Types and Operations 1467 Part III, Statements and Syntax 1473 Table of Contents | xxxi
- 34. Part IV, Functions and Generators 1475 Part V, Modules and Packages 1485 Part VI, Classes and OOP 1489 Part VII, Exceptions and Tools 1497 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1507 xxxii | Table of Contents
- 35. Preface If you’re standing in a bookstore looking for the short story on this book, try this: • Python is a powerful multiparadigm computer programming language, optimized for programmer productivity, code readability, and software quality. • This book provides a comprehensive and in-depth introduction to the Python lan- guage itself. Its goal is to help you master Python fundamentals before moving on to apply them in your work. Like all its prior editions, this book is designed to serve as a single, all-inclusive learning resource for all Python newcomers, whether they will be using Python 2.X, Python 3.X, or both. • This edition has been brought up to date with Python releases 3.3 and 2.7, and has been expanded substantially to reflect current practice in the Python world. Thisprefacedescribesthisbook’sgoals,scope,andstructureinmoredetail.It’soptional reading, but is designed to provide some orientation before you get started with the book at large. This Book’s “Ecosystem” Python is a popular open source programming language used for both standalone pro- grams and scripting applications in a wide variety of domains. It is free, portable, pow- erful, and is both relatively easy and remarkably fun to use. Programmers from every corner of the software industry have found Python’s focus on developer productivity and software quality to be a strategic advantage in projects both large and small. Whether you are new to programming or are a professional developer, this book is designed to bring you up to speed on the Python language in ways that more limited approaches cannot. After reading this book, you should know enough about Python to apply it in whatever application domains you choose to explore. By design, this book is a tutorial that emphasizes the core Python language itself, rather than specific applications of it. As such, this book is intended to serve as the first in a two-volume set: xxxiii
- 36. • Learning Python, this book, teaches Python itself, focusing on language funda- mentals that span domains. • Programming Python, among others, moves on to show what you can do with Python after you’ve learned it. This division of labor is deliberate. While application goals can vary per reader, the need for useful language fundamentals coverage does not. Applications-focused books such as Programming Python pick up where this book leaves off, using realistically scaled examples to explore Python’s role in common domains such as the Web, GUIs, systems, databases, and text. In addition, the book Python Pocket Reference provides reference materials not included here, and it is designed to supplement this book. Because of this book’s focus on foundations, though, it is able to present Python lan- guage fundamentals with more depth than many programmers see when first learning the language. Its bottom-up approach and self-contained didactic examples are de- signed to teach readers the entire language one step at a time. The core language skills you’ll gain in the process will apply to every Python software system you’ll encounter—be it today’s popular tools such as Django, NumPy, and App Engine, or others that may be a part of both Python’s future and your programming career. Because it’s based upon a three-day Python training class with quizzes and exercises throughout,thisbookalsoservesasaself-pacedintroductiontothelanguage.Although its format lacks the live interaction of a class, it compensates in the extra depth and flexibility that only a book can provide. Though there are many ways to use this book, linear readers will find it roughly equivalent to a semester-long Python class. About This Fifth Edition The prior fourth edition of this book published in 2009 covered Python versions 2.6 and 3.0.1 It addressed the many and sometimes incompatible changes introduced in the Python 3.X line in general. It also introduced a new OOP tutorial, and new chapters on advanced topics such as Unicode text, decorators, and metaclasses, derived from both the live classes I teach and evolution in Python “best practice.” This fifth edition completed in 2013 is a revision of the prior, updated to cover both Python 3.3 and 2.7, the current latest releases in the 3.X and 2.X lines. It incorporates 1. And2007’sshort-livedthirdeditioncoveredPython2.5,anditssimpler—andshorter—single-linePython world. See http://www.rmi.net/~lutz for more on this book’s history. Over the years, this book has grown in size and complexity in direct proportion to Python’s own growth. Per Appendix C, Python 3.0 alone introduced 27 additions and 57 changes in the language that found their way into this book, and Python 3.3 continues this trend. Today’s Python programmer faces two incompatible lines, three major paradigms, a plethora of advanced tools, and a blizzard of feature redundancy—most of which do not divide neatly between the 2.X and 3.X lines. That’s not as daunting as it may sound (many tools are variations on a theme), but all are fair game in an inclusive, comprehensive Python text. xxxiv | Preface
- 37. all language changes introduced in each line since the prior edition was published, and has been polished throughout to update and sharpen its presentation. Specifically: • Python 2.X coverage here has been updated to include features such as dictionary andsetcomprehensionsthatwereformerlyfor3.Xonly,buthavebeenback-ported for use in 2.7. • Python 3.X coverage has been augmented for new yield and raise syntax; the __pycache__ bytecode model; 3.3 namespace packages; PyDoc’s all-browser mode; Unicode literal and storage changes; and the new Windows launcher shipped with 3.3. • Assorted new or expanded coverage for JSON, timeit, PyPy, os.popen, generators, recursion, weak references, __mro__, __iter__, super, __slots__, metaclasses, de- scriptors, random, Sphinx, and more has been added, along with a general increase in 2.X compatibility in both examples and narrative. This edition also adds a new conclusion as Chapter 41 (on Python’s evolution), two new appendixes (on recent Python changes and the new Windows launcher), and one new chapter (on benchmarking: an expanded version of the former code timing exam- ple).SeeAppendixCforaconcisesummaryofPythonchangesbetweentheprioredition and this one, as well as links to their coverage in the book. This appendix also sum- marizes initial differences between 2.X and 3.X in general that were first addressed in the prior edition, though some, such as new-style classes, span versions and simply become mandated in 3.X (more on what the X’s mean in a moment). Per the last bullet in the preceding list, this edition has also experienced some growth because it gives fuller coverage to more advanced language features—which many of us have tried very hard to ignore as optional for the last decade, but which have now grown more common in Python code. As we’ll see, these tools make Python more powerful, but also raise the bar for newcomers, and may shift Python’s scope and definition. Because you might encounter any of these, this book covers them head-on, instead of pretending they do not exist. Despite the updates, this edition retains most of the structure and content of the prior edition, and is still designed to be a comprehensive learning resource for both the 2.X and 3.X Python lines. While it is primarily focused on users of Python 3.3 and 2.7— the latest in the 3.X line and the likely last in the 2.X line—its historical perspective also makes it relevant to older Pythons that still see regular use today. Though it’s impossible to predict the future, this book stresses fundamentals that have been valid for nearly two decades, and will likely apply to future Pythons too. As usual, I’ll be posting Python updates that impact this book at the book’s website described ahead. The “What’s New” documents in Python’s manuals set can also serve to fill in the gaps as Python surely evolves after this book is published. Preface | xxxv
- 38. The Python 2.X and 3.X Lines Because it bears heavily on this book’s content, I need to say a few more words about the Python 2.X/3.X story up front. When the fourth edition of this book was written in 2009, Python had just become available in two flavors: • Version 3.0 was the first in the line of an emerging and incompatible mutation of the language known generically as 3.X. • Version 2.6 retained backward compatibility with the vast body of existing Python code, and was the latest in the line known collectively as 2.X. While 3.X was largely the same language, it ran almost no code written for prior re- leases. It: • Imposed a Unicode model with broad consequences for strings, files, and libraries • Elevated iterators and generators to a more pervasive role, as part of fuller func- tional paradigm • Mandated new-style classes, which merge with types, but grow more powerful and complex • Changed many fundamental tools and libraries, and replaced or removed others entirely The mutation of print from statement to function alone, aesthetically sound as it may be, broke nearly every Python program ever written. And strategic potential aside, 3.X’s mandatory Unicode and class models and ubiquitous generators made for a different programming experience. Although many viewed Python 3.X as both an improvement and the future of Python, Python 2.X was still very widely used and was to be supported in parallel with Python 3.X for years to come. The majority of Python code in use was 2.X, and migration to 3.X seemed to be shaping up to be a slow process. The 2.X/3.X Story Today As this fifth edition is being written in 2013, Python has moved on to versions 3.3 and 2.7,butthis2.X/3.Xstoryisstilllargelyunchanged.Infact, Pythonisnowadual-version world, with many users running both 2.X and 3.X according to their software goals and dependencies. And for many newcomers, the choice between 2.X and 3.X remains one of existing software versus the language’s cutting edge. Although many major Python packages have been ported to 3.X, many others are still 2.X-only today. To some observers, Python 3.X is now seen as a sandbox for exploring new ideas, while 2.X is viewed as the tried-and-true Python, which doesn’t have all of 3.X’s features but is still more pervasive. Others still see Python 3.X as the future, a view that seems supported by current core developer plans: Python 2.7 will continue to be supported but is to be the last 2.X, while 3.3 is the latest in the 3.X line’s continuing evolution. xxxvi | Preface
- 39. On the other hand, initiatives such as PyPy—today a still 2.X-only implementation of Python that offers stunning performance improvements—represent a 2.X future, if not an outright faction. All opinions aside, almost five years after its release, 3.X has yet to supersede 2.X, or even match its user base. As one metric, 2.X is still downloaded more often than 3.X for Windows at python.org today, despite the fact that this measure would be naturally skewed to new users and the most recent release. Such statistics are prone to change, of course, but after five years are indicative of 3.X uptake nonetheless. The existing 2.X software base still trumps 3.X’s language extensions for many. Moreover, being last in the 2.X line makes 2.7 a sort of de facto standard, immune to the constant pace of change in the 3.X line—a positive to those who seek a stable base, and a negative to those who seek growth and ongoing relevance. Personally, I think today’s Python world is large enough to accommodate both 3.X and 2.X; they seem to satisfy different goals and appeal to different camps, and there is precedence for this in other language families (C and C++, for example, have a long- standing coexistence, though they may differ more than Python 2.X and 3.X). More- over, because they are so similar, the skills gained by learning either Python line transfer almost entirely to the other, especially if you’re aided by dual-version resources like this book. In fact, as long as you understand how they diverge, it’s often possible to write code that runs on both. At the same time, this split presents a substantial dilemma for both programmers and book authors, which shows no signs of abating. While it would be easier for a book to pretend that Python 2.X never existed and cover 3.X only, this would not address the needs of the large Python user base that exists today. A vast amount of existing code was written for Python 2.X, and it won’t be going away anytime soon. And while some newcomers to the language can and should focus on Python 3.X, anyone who must use code written in the past needs to keep one foot in the Python 2.X world today. Since it may still be years before many third-party libraries and extensions are ported to Python 3.X, this fork might not be entirely temporary. Coverage for Both 3.X and 2.X To address this dichotomy and to meet the needs of all potential readers, this book has been updated to cover both Python 3.3 and Python 2.7, and should apply to later re- leases in both the 3.X and 2.X lines. It’s intended for programmers using Python 2.X, programmers using Python 3.X, and programmers stuck somewhere between the two. That is, you can use this book to learn either Python line. Although 3.X is often em- phasized, 2.X differences and tools are also noted along the way for programmers using older code. While the two versions are largely similar, they diverge in some important ways, and I’ll point these out as they crop up. Preface | xxxvii
- 40. For instance, I’ll use 3.X print calls in most examples, but will also describe the 2.X print statement so you can make sense of earlier code, and will often use portable printing techniques that run on both lines. I’ll also freely introduce new features, such as the nonlocal statement in 3.X and the string format method available as of 2.6 and 3.0, and will point out when such extensions are not present in older Pythons. By proxy, this edition addresses other Python version 2.X and 3.X releases as well, though some older version 2.X code may not be able to run all the examples here. Although class decorators are available as of both Python 2.6 and 3.0, for example, you cannot use them in an older Python 2.X that did not yet have this feature. Again, see the change tables in Appendix C for summaries of recent 2.X and 3.X changes. Which Python Should I Use? Version choice may be mandated by your organization, but if you’re new to Python and learning on your own, you may be wondering which version to install. The answer here depends on your goals. Here are a few suggestions on the choice. When to choose 3.X: new features, evolution If you are learning Python for the first time and don’t need to use any existing 2.X code, I encourage you to begin with Python 3.X. It cleans up some longstanding warts in the language and trims some dated cruft, while retaining all the original core ideas and adding some nice new tools. For example, 3.X’s seamless Unicode model and broader use of generators and functional techniques are seen by many users as assets. Many popular Python libraries and tools are already available for Python 3.X, or will be by the time you read these words, especially given the con- tinual improvements in the 3.X line. All new language evolution occurs in 3.X only, which adds features and keeps Python relevant, but also makes language definition a constantly moving target—a tradeoff inherent on the leading edge. When to choose 2.X: existing code, stability If you’ll be using a system based on Python 2.X, the 3.X line may not be an option for you today. However, you’ll find that this book addresses your concerns, too, and will help if you migrate to 3.X in the future. You’ll also find that you’re in large company. Every group I taught in 2012 was using 2.X only, and I still regularly see useful Python software in 2.X-only form. Moreover, unlike 3.X, 2.X is no longer being changed—which is either an asset or liability, depending on whom you ask. There’s nothing wrong with using and writing 2.X code, but you may wish to keep tabs on 3.X and its ongoing evolution as you do. Python’s future remains to be written, and is largely up to its users, including you. When to choose both: version-neutral code Probably the best news here is that Python’s fundamentals are the same in both its lines—2.X and 3.X differ in ways that many users will find minor, and this book is designed to help you learn both. In fact, as long as you understand their differ- ences, it’s often straightforward to write version-neutral code that runs on both xxxviii | Preface
- 41. Pythons, as we regularly will in this book. See Appendix C for pointers on 2.X/3.X migration and tips on writing code for both Python lines and audiences. Regardless of which version or versions you choose to focus on first, your skills will transfer directly to wherever your Python work leads you. About the Xs: Throughout this book, “3.X” and “2.X” are used to refer collectively to all releases in these two lines. For instance, 3.X includes 3.0 through 3.3, and future 3.X releases; 2.X means all from 2.0 through 2.7 (and presumably no others). More specific releases are mentioned when a topic applies to it only (e.g., 2.7’s set literals and 3.3’s launcher and namespace packages). This notation may occasionally be too broad —some features labeled 2.X here may not be present in early 2.X releases rarely used today—but it accommodates a 2.X line that has already spanned 13 years. The 3.X label is more easily and accurately applied to this younger five-year-old line. This Book’s Prerequisites and Effort It’s impossible to give absolute prerequisites for this book, because its utility and value candependasmuchonreadermotivationasonreaderbackground.Bothtruebeginners and crusty programming veterans have used this book successfully in the past. If you are motivated to learn Python, and willing to invest the time and focus it requires, this text will probably work for you. Just how much time is required to learn Python? Although this will vary per learner, this book tends to work best when read. Some readers may use this book as an on- demand reference resource, but most people seeking Python mastery should expect to spend at least weeks and probably months going through the material here, depending on how closely they follow along with its examples. As mentioned, it’s roughly equiv- alent to a full-semester course on the Python language itself. That’s the estimate for learning just Python itself and the software skills required to use it well. Though this book may suffice for basic scripting goals, readers hoping to pursue software development at large as a career should expect to devote additional time after this book to large-scale project experience, and possibly to follow-up texts such as Programming Python.2 2. The standard disclaimer: I wrote this and another book mentioned earlier, which work together as a set: Learning Python for language fundamentals, Programming Python for applications basics, and Python Pocket Reference as a companion to the other two. All three derive from 1995’s original and broad Programming Python. I encourage you to explore the many Python books available today (I stopped counting at 200 at Amazon.com just now because there was no end in sight, and this didn’t include related subjects like Django). My own publisher has recently produced Python-focused books on instrumentation, data mining, App Engine, numeric analysis, natural language processing, MongoDB, AWS, and more—specific domains you may wish to explore once you’ve mastered Python language fundamentals here. The Python story today is far too rich for any one book to address alone. Preface | xxxix
- 42. That may not be welcome news to people looking for instant proficiency, but pro- gramming is not a trivial skill (despite what you may have heard!). Today’s Python, and software in general, are both challenging and rewarding enough to merit the effort implied by comprehensive books such as this. Here are a few pointers on using this book for readers on both sides of the experience spectrum: To experienced programmers You have an initial advantage and can move quickly through some earlier chapters; but you shouldn’t skip the core ideas, and may need to work at letting go of some baggage. In general terms, exposure to any programming or scripting before this book might be helpful because of the analogies it may provide. On the other hand, I’ve also found that prior programming experience can be a handicap due to ex- pectations rooted in other languages (it’s far too easy to spot the Java or C++ programmers in classes by the first Python code they write!). Using Python well requires adopting its mindset. By focusing on key core concepts, this book is de- signed to help you learn to code Python in Python. To true beginners You can learn Python here too, as well as programming itself; but you may need to work a bit harder, and may wish to supplement this text with gentler introduc- tions. If you don’t consider yourself a programmer already, you will probably find this book useful too, but you’ll want to be sure to proceed slowly and work through the examples and exercises along the way. Also keep in mind that this book will spend more time teaching Python itself than programming basics. If you find your- selflosthere,Iencourageyoutoexploreanintroductiontoprogrammingingeneral before tackling this book. Python’s website has links to many helpful resources for beginners. Formally, this book is designed to serve as a first Python text for newcomers of all kinds. It may not be an ideal resource for someone who has never touched a computer before (for instance, we’re not going to spend any time exploring what a computer is), but I haven’t made many assumptions about your programming background or edu- cation. On the other hand, I won’t insult readers by assuming they are “dummies,” either, whatever that means—it’s easy to do useful things in Python, and this book will show you how. The text occasionally contrasts Python with languages such as C, C++, Java, and others, but you can safely ignore these comparisons if you haven’t used such lan- guages in the past. This Book’s Structure To help orient you, this section provides a quick rundown of the content and goals of the major parts of this book. If you’re anxious to get to it, you should feel free to skip xl | Preface
- 43. this section (or browse the table of contents instead). To some readers, though, a book this large probably merits a brief roadmap up front. By design, each part covers a major functional area of the language, and each part is composed of chapters focusing on a specific topic or aspect of the part’s area. In addi- tion, each chapter ends with quizzes and their answers, and each part ends with larger exercises, whose solutions show up in Appendix D. Practice matters: I strongly recommend that readers work through the quizzes and exercises in this book, and work along with its examples in general if you can. In programming, there’s no substitute for practicing what you’ve read. Whether you do it with this book or a project of your own, actual coding is crucial if you want the ideas presented here to stick. Overall, this book’s presentation is bottom-up because Python is too. The examples and topics grow more challenging as we move along. For instance, Python’s classes are largely just packages of functions that process built-in types. Once you’ve mastered built-in types and functions, classes become a relatively minor intellectual leap. Because each part builds on those preceding it this way, most readers will find a linear reading makes the most sense. Here’s a preview of the book’s main parts you’ll find along the way: Part I We begin with a general overview of Python that answers commonly asked initial questions—why people use the language, what it’s useful for, and so on. The first chapter introduces the major ideas underlying the technology to give you some background context. The rest of this part moves on to explore the ways that both Python and programmers run programs. The main goal here is to give you just enough information to be able to follow along with later examples and exercises. Part II Next, we begin our tour of the Python language, studying Python’s major built-in object types and what you can do with them in depth: numbers, lists, dictionaries, and so on. You can get a lot done with these tools alone, and they are at the heart of every Python script. This is the most substantial part of the book because we lay groundwork here for later chapters. We’ll also explore dynamic typing and its references—keys to using Python well—in this part. Part III The next part moves on to introduce Python’s statements—the code you type to create and process objects in Python. It also presents Python’s general syntax model. Although this part focuses on syntax, it also introduces some related tools (such as the PyDoc system), takes a first look at iteration concepts, and explores coding alternatives. Preface | xli
- 44. Part IV This part begins our look at Python’s higher-level program structure tools. Func- tions turn out to be a simple way to package code for reuse and avoid code redun- dancy. In this part, we will explore Python’s scoping rules, argument-passing tech- niques, the sometimes-notorious lambda, and more. We’ll also revisit iterators from a functional programming perspective, introduce user-defined generators, and learn how to time Python code to measure performance here. Part V Python modules let you organize statements and functions into larger components, and this part illustrates how to create, use, and reload modules. We’ll also look at some more advanced topics here, such as module packages, module reloading, package-relative imports, 3.3’s new namespace packages, and the __name__ vari- able. Part VI Here, we explore Python’s object-oriented programming tool, the class—an op- tional but powerful way to structure code for customization and reuse, which al- most naturally minimizes redundancy. As you’ll see, classes mostly reuse ideas we will have covered by this point in the book, and OOP in Python is mostly about looking up names in linked objects with a special first argument in functions. As you’ll also see, OOP is optional in Python, but most find Python’s OOP to be much simpler than others, and it can shave development time substantially, especially for long-term strategic project development. Part VII We conclude the language fundamentals coverage in this text with a look at Python’s exception handling model and statements, plus a brief overview of de- velopment tools that will become more useful when you start writing larger pro- grams (debugging and testing tools, for instance). Although exceptions are a fairly lightweight tool, this part appears after the discussion of classes because user-de- fined exceptions should now all be classes. We also cover some more advanced topics, such as context managers, here. Part VIII In the final part, we explore some advanced topics: Unicode and byte strings, managed attribute tools like properties and descriptors, function and class deco- rators, and metaclasses. These chapters are all optional reading, because not all programmers need to understand the subjects they address. On the other hand, readers who must process internationalized text or binary data, or are responsible for developing APIs for other programmers to use, should find something of in- terest in this part. The examples here are also larger than most of those in this book, and can serve as self-study material. Part IX The book wraps up with a set of four appendixes that give platform-specific tips for installing and using Python on various computers; present the new Windows xlii | Preface
- 45. launcher that ships with Python 3.3; summarize changes in Python addressed by recent editions and give links to their coverage here; and provide solutions to the end-of-part exercises. Solutions to end-of-chapter quizzes appear in the chapters themselves. See the table of contents for a finer-grained look at this book’s components. What This Book Is Not Given its relatively large audience over the years, some have inevitably expected this book to serve a role outside its scope. So now that I’ve told you what this book is, I also want to be clear on what it isn’t: • This book is a tutorial, not a reference. • This book covers the language itself, not applications, standard libraries, or third- party tools. • This book is a comprehensive look at a substantial topic, not a watered-down overview. Because these points are key to this book’s content, I want to say a few more words about them up front. It’s Not a Reference or a Guide to Specific Applications This book is a language tutorial, not a reference, and not an applications book. This is by design: today’s Python—with its built-in types, generators, closures, comprehen- sions, Unicode, decorators, and blend of procedural, object-oriented, and functional programming paradigms—makes the core language a substantial topic all by itself, and a prerequisite to all your future Python work, in whatever domains you pursue. When you are ready for other resources, though, here are a few suggestions and reminders: Reference resources As implied by the preceding structural description, you can use the index and table of contents to hunt for details, but there are no reference appendixes in this book. If you are looking for Python reference resources (and most readers probably will be very soon in their Python careers), I suggest the previously mentioned book that I also wrote as a companion to this one—Python Pocket Reference—as well as other reference books you’ll find with a quick search, and the standard Python reference manuals maintained at http://www.python.org. The latter of these are free, always up to date, and available both on the Web and on your computer after a Windows install. Applications and libraries As also discussed earlier, this book is not a guide to specific applications such as the Web, GUIs, or systems programming. By proxy, this includes the libraries and Preface | xliii
- 46. tools used in applications work; although some standard libraries and tools are introduced here—including timeit, shelve, pickle, struct, json, pdb, os, urllib, re, xml, random, PyDoc and IDLE—they are not officially in this book’s primary scope. If you’re looking for more coverage on such topics and are already proficient with Python, I recommend the follow-up book Programming Python, among oth- ers. That book assumes this one as its prerequisite, though, so be sure you have a firm grasp of the core language first. Especially in an engineering domain like soft- ware, one must walk before one runs. It’s Not the Short Story for People in a Hurry As you can tell from its size, this book also doesn’t skimp on the details: it presents the full Python language, not a brief look at a simplified subset. Along the way it also covers software principles that are essential to writing good Python code. As mentioned, this is a multiple-week or -month book, designed to impart the skill level you’d acquire from a full-term class on Python. This is also deliberate. Many of this book’s readers don’t need to acquire full-scale software development skills, of course, and some can absorb Python in a piecemeal fashion. At the same time, because any part of the language may be used in code you will encounter, no part is truly optional for most programmers. Moreover, even casual scripters and hobbyists need to know basic principles of software development in order to code well, and even to use precoded tools properly. This book aims to address both of these needs—language and principles—in enough depth to be useful. In the end, though, you’ll find that Python’s more advanced tools, such as its object-oriented and functional programming support, are relatively easy to learn once you’ve mastered their prerequisites—and you will, if you work through this book one chapter at a time. It’s as Linear as Python Allows Speaking of reading order, this edition also tries hard to minimize forward references, but Python 3.X’s changes make this impossible in some cases (in fact, 3.X sometimes seems to assume you already know Python while you’re learning it!). As a handful of representative examples: • Printing, sorts, the string format method, and some dict calls rely on function keyword arguments. • Dictionary key lists and tests, and the list calls used around many tools, imply iteration concepts. • Using exec to run code now assumes knowledge of file objects and interfaces. • Coding new exceptions requires classes and OOP fundamentals. xliv | Preface
- 47. • And so on—even basic inheritance broaches advanced topics such as metaclasses and descriptors. Python is still best learned as a progression from simple to advanced, and a linear reading here still makes the most sense. Still, some topics may require nonlinear jumps andrandomlookups.Tominimizethese,thisbookwillpointoutforwarddependencies when they occur, and will ease their impacts as much as possible. But if your time is tight: Though depth is crucial to mastering Python, some readers may have limited time. If you are interested in starting out with a quick Python tour, I suggest Chapter 1, Chapter 4, Chapter 10, and Chapter 28 (and perhaps 26)—a short survey that will hopefully pique your interest in the more complete story told in the rest of the book, and which most readers will need in today’s Python software world. In general, this book is intentionally layered this way to make its material easier to absorb—with introductions followed by details, so you can start with overviews, and dig deeper over time. You don’t need to read this book all at once, but its gradual approach is designed to help you tackle its material eventually. This Book’s Programs In general, this book has always strived to be agnostic about both Python versions and platforms. It’s designed to be useful to all Python users. Nevertheless, because Python changes over time and platforms tend to differ in pragmatic ways, I need to describe the specific systems you’ll see in action in most examples here. Python Versions This fifth edition of this book, and all the program examples in it, are based on Python versions 3.3 and 2.7. In addition, many of its examples run under prior 3.X and 2.X releases, and notes about the history of language changes in earlier versions are mixed in along the way for users of older Pythons. Because this text focuses on the core language, however, you can be fairly sure that most of what it has to say won’t change very much in future releases of Python, as noted earlier. Most of this book applies to earlier Python versions, too, except when it does not; naturally, if you try using extensions added after a release you’re using, all bets are off. As a rule of thumb, the latest Python is the best Python if you are able to upgrade. Because this book focuses on the core language, most of it also applies to both Jython and IronPython, the Java- and .NET-based Python language implementations, as well as other Python implementations such as Stackless and PyPy (described in Chapter 2). Such alternatives differ mostly in usage details, not language. Preface | xlv
- 48. Platforms The examples in this book were run on a Windows 7 and 8 ultrabook,3 though Python’s portability makes this mostly a moot point, especially in this fundamentals-focused book. You’ll notice a few Windows-isms—including command-line prompts, a hand- ful of screenshots, install pointers, and an appendix on the new Windows launcher in 3.3—but this reflects the fact that most Python newcomers will probably get started on this platform, and these can be safely ignored by users of other operating systems. I also give a few launching details for other platforms like Linux, such as “#!” line use, but as we’ll see in Chapter 3 and Appendix B, the 3.3 Windows launcher makes even this a more portable technique. Fetching This Book’s Code Source code for the book’s examples, as well as exercise solutions, can be fetched as a zip file from the book’s website at the following address: http://oreil.ly/LearningPython-5E This site includes both all the code in this book as well as package usage instructions, so I’ll defer to it for more details. Of course, the examples work best in the context of their appearance in this book, and you’ll need some background knowledge on running Python programs in general to make use of them. We’ll study startup details in Chap- ter 3, so please stay tuned for information on this front. Using This Book’s Code The code in my Python books is designed to teach, and I’m glad when it assists readers in that capacity. O’Reilly itself has an official policy regarding reusing the book’s ex- amples in general, which I’ve pasted into the rest of this section for reference: This book is here to help you get your job done. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a pro- gram that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission. 3. Mostly under Windows 7, but it’s irrelevant to this book. At this writing, Python installs on Windows 8 and runs in its desktop mode, which is essentially the same as Windows 7 without a Start button as I write this (you may need to create shortcuts for former Start button menu items). Support for WinRT/ Metro “apps” is still pending. See Appendix A for more details. Frankly, the future of Windows 8 is unclear as I type these words, so this book will be as version-neutral as possible. xlvi | Preface
- 49. We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: “Learning Python, Fifth Edition, by Mark Lutz. Copyright 2013 Mark Lutz, 978-1-4493-5573-9.” If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at [email protected]. Font Conventions This book’s mechanics will make more sense once you start reading it, of course, but as a reference, this book uses the following typographical conventions: Italic Used for email addresses, URLs, filenames, pathnames, and emphasizing new terms when they are first introduced Constant width Used for program code, the contents of files and the output from commands, and to designate modules, methods, statements, and system commands Constant width bold Used in code sections to show commands or text that would be typed by the user, and, occasionally, to highlight portions of code Constant width italic Used for replaceables and some comments in code sections Indicates a tip, suggestion, or general note relating to the nearby text. Indicates a warning or caution relating to the nearby text. You’ll also find occasional sidebars (delimited by boxes) and footnotes (at page end) throughout, which are often optional reading, but provide additional context on the topics being presented. The sidebars in “Why You Will Care: Slices” on page 204, for example, often give example use cases for the subjects being explored. Book Updates and Resources Improvements happen (and so do mis^H^H^H typos). Updates, supplements, and cor- rections (a.k.a. errata) for this book will be maintained on the Web, and may be sug- gested at either the publisher’s website or by email. Here are the main coordinates: Preface | xlvii
- 50. Publisher’s site: http://oreil.ly/LearningPython-5E This site will maintain this edition’s official list of book errata, and chronicle spe- cific patches applied to the text in reprints. It’s also the official site for the book’s examples as described earlier. Author’s site: http://www.rmi.net/~lutz/about-lp5e.html This site will be used to post more general updates related to this text or Python itself—a hedge against future changes, which should be considered a sort of virtual appendix to this book. My publisher also has an email address for comments and technical questions about this book: [email protected] For more information about my publisher’s books, conferences, Resource Centers, and the O’Reilly Network, see its general website: http://www.oreilly.com For more on my books, see my own book support site: http://rmi.net/~lutz Also be sure to search the Web if any of the preceding links become invalid over time; if I could become more clairvoyant, I would, but the Web changes faster than published books. Acknowledgments As I write this fifth edition of this book in 2013, it’s difficult to not be somewhat ret- rospective. I have now been using and promoting Python for 21 years, writing books about it for 18, and teaching live classes on it for 16. Despite the passage of time, I’m still regularly amazed at how successful Python has been—in ways that most of us could notpossiblyhaveimaginedintheearly1990s.Soattheriskofsoundinglikeahopelessly self-absorbed author, I hope you’ll pardon a few closing words of history and gratitude here. The Backstory My own Python history predates both Python 1.0 and the Web (and goes back to a time when an install meant fetching email messages, concatenating, decoding, and hoping it all somehow worked). When I first discovered Python as a frustrated C++ software developer in 1992, I had no idea what an impact it would have on the next two decades of my life. Two years after writing the first edition of Programming Python in 1995 for Python 1.3, I began traveling around the country and world teaching Python to beginners and experts. Since finishing the first edition of Learning Python in xlviii | Preface
- 51. 1999, I’ve been an independent Python trainer and writer, thanks in part to Python’s phenomenal growth in popularity. Here’s the damage so far. I’ve now written 13 Python books (5 of this, and 4 of two others), which have together sold some 400,000 units by my data. I’ve also been teach- ing Python for over a decade and a half; have taught some 260 Python training sessions in the U.S., Europe, Canada, and Mexico; and have met roughly 4,000 students along the way. Besides propelling me toward frequent flyer utopia, these classes helped me refine this text and my other Python books. Teaching honed the books, and vice versa, with the net result that my books closely parallel what happens in my classes, and can serve as a viable alternative to them. As for Python itself, in recent years it has grown to become one of the top 5 to 10 most widely used programming languages in the world (depending on which source you cite and when you cite it). Because we’ll be exploring Python’s status in the first chapter of this book, I’ll defer the rest of this story until then. Python Thanks Because teaching teaches teachers to teach, this book owes much to my live classes. I’d like to thank all the students who have participated in my courses during the last 16 years. Along with changes in Python itself, your feedback played a major role in shaping this text; there’s nothing quite as instructive as watching 4,000 people repeat the same beginner mistakes live and in person! This book’s recent editions owe their training- based changes primarily to recent classes, though every class held since 1997 has in some way helped refine this book. I’d like to thank clients who hosted classes in Dublin, Mexico City, Barcelona, London, Edmonton, and Puerto Rico; such experiences have been one of my career’s most lasting rewards. Because writing teaches writers to write, this book also owes much to its audience. I want to thank the countless readers who took time to offer suggestions over the last 18 years, both online and in person. Your feedback has also been vital to this book’s evo- lution and a substantial factor in its success, a benefit that seems inherent in the open source world. Reader comments have run the gamut from “You should be banned from writing books” to “God bless you for writing this book”; if consensus is possible in such matters it probably lies somewhere between these two, though to borrow a line from Tolkien: the book is still too short. I’d also like to express my gratitude to everyone who played a part in this book’s production. To all those who have helped make this book a solid product over the years —including its editors, formatters, marketers, technical reviewers, and more. And to O’Reilly for giving me a chance to work on 13 book projects; it’s been net fun (and only feels a little like the movie Groundhog Day). Additional thanks is due to the entire Python community; like most open source sys- tems, Python is the product of many unsung efforts. It’s been my privilege to watch Preface | xlix
- 52. Python grow from a new kid on the scripting languages block to a widely used tool, deployed in some fashion by almost every organization writing software. Technical disagreements aside, that’s been an exciting endeavor to be a part of. I also want to thank my original editor at O’Reilly, the late Frank Willison. This book was largely Frank’s idea. He had a profound impact on both my career and the success of Python when it was new, a legacy that I remember each time I’m tempted to misuse the word “only.” Personal Thanks Finally, a few more personal notes of thanks. To the late Carl Sagan, for inspiring an 18-year-old kid from Wisconsin. To my Mother, for courage. To my siblings, for the truths to be found in museum peanuts. To the book The Shallows, for a much-needed wakeup call. To my son Michael and daughters Samantha and Roxanne, for who you are. I’m not quite sure when you grew up, but I’m proud of how you did, and look forward to seeing where life takes you next. And to my wife Vera, for patience, proofing, Diet Cokes, and pretzels. I’m glad I finally found you. I don’t know what the next 50 years hold, but I do know that I hope to spend all of them holding you. —Mark Lutz, Amongst the Larch, Spring 2013 l | Preface
- 55. CHAPTER 1 A Python Q&A Session If you’ve bought this book, you may already know what Python is and why it’s an important tool to learn. If you don’t, you probably won’t be sold on Python until you’ve learned the language by reading the rest of this book and have done a project or two. But before we jump into details, this first chapter of this book will briefly introduce some of the main reasons behind Python’s popularity. To begin sculpting a definition of Python, this chapter takes the form of a question-and-answer session, which poses some of the most common questions asked by beginners. Why Do People Use Python? Because there are many programming languages available today, this is the usual first question of newcomers. Given that there are roughly 1 million Python users out there at the moment, there really is no way to answer this question with complete accuracy; the choice of development tools is sometimes based on unique constraints or personal preference. But after teaching Python to roughly 260 groups and over 4,000 students during the last 16 years, I have seen some common themes emerge. The primary factors cited by Python users seem to be these: Software quality For many, Python’s focus on readability, coherence, and software quality in general sets it apart from other tools in the scripting world. Python code is designed to be readable, and hence reusable and maintainable—much more so than traditional scripting languages. The uniformity of Python code makes it easy to understand, even if you did not write it. In addition, Python has deep support for more advanced software reuse mechanisms, such as object-oriented (OO) and function program- ming. Developer productivity Python boosts developer productivity many times beyond compiled or statically typed languages such as C, C++, and Java. Python code is typically one-third to 3
- 56. one-fifth the size of equivalent C++ or Java code. That means there is less to type, less to debug, and less to maintain after the fact. Python programs also run imme- diately, without the lengthy compile and link steps required by some other tools, further boosting programmer speed. Program portability Most Python programs run unchanged on all major computer platforms. Porting Python code between Linux and Windows, for example, is usually just a matter of copying a script’s code between machines. Moreover, Python offers multiple op- tions for coding portable graphical user interfaces, database access programs, web- based systems, and more. Even operating system interfaces, including program launches and directory processing, are as portable in Python as they can possibly be. Support libraries Python comes with a large collection of prebuilt and portable functionality, known as the standard library. This library supports an array of application-level pro- gramming tasks, from text pattern matching to network scripting. In addition, Python can be extended with both homegrown libraries and a vast collection of third-party application support software. Python’s third-party domain offers tools for website construction, numeric programming, serial port access, game devel- opment, and much more (see ahead for a sampling). The NumPy extension, for instance, has been described as a free and more powerful equivalent to the Matlab numeric programming system. Component integration Python scripts can easily communicate with other parts of an application, using a variety of integration mechanisms. Such integrations allow Python to be used as a product customization and extension tool. Today, Python code can invoke C and C++ libraries, can be called from C and C++ programs, can integrate with Java and .NET components, can communicate over frameworks such as COM and Sil- verlight, can interface with devices over serial ports, and can interact over networks with interfaces like SOAP, XML-RPC, and CORBA. It is not a standalone tool. Enjoyment Because of Python’s ease of use and built-in toolset, it can make the act of pro- gramming more pleasure than chore. Although this may be an intangible benefit, its effect on productivity is an important asset. Of these factors, the first two (quality and productivity) are probably the most com- pelling benefits to most Python users, and merit a fuller description. Software Quality By design, Python implements a deliberately simple and readable syntax and a highly coherent programming model. As a slogan at a past Python conference attests, the net result is that Python seems to “fit your brain”—that is, features of the language interact 4 | Chapter 1: A Python Q&A Session
- 57. in consistent and limited ways and follow naturally from a small set of core concepts. This makes the language easier to learn, understand, and remember. In practice, Python programmers do not need to constantly refer to manuals when reading or writing code; it’s a consistently designed system that many find yields surprisingly uniform code. By philosophy, Python adopts a somewhat minimalist approach. This means that al- though there are usually multiple ways to accomplish a coding task, there is usually just one obvious way, a few less obvious alternatives, and a small set of coherent in- teractions everywhere in the language. Moreover, Python doesn’t make arbitrary deci- sions for you; when interactions are ambiguous, explicit intervention is preferred over “magic.” In the Python way of thinking, explicit is better than implicit, and simple is better than complex.1 Beyond such design themes, Python includes tools such as modules and OOP that naturally promote code reusability. And because Python is focused on quality, so too, naturally, are Python programmers. Developer Productivity During the great Internet boom of the mid-to-late 1990s, it was difficult to find enough programmers to implement software projects; developers were asked to implement systems as fast as the Internet evolved. In later eras of layoffs and economic recession, the picture shifted. Programming staffs were often asked to accomplish the same tasks with even fewer people. In both of these scenarios, Python has shined as a tool that allows programmers to get more done with less effort. It is deliberately optimized for speed of development—its simple syntax, dynamic typing, lack of compile steps, and built-in toolset allow pro- grammers to develop programs in a fraction of the time needed when using some other tools. The net effect is that Python typically boosts developer productivity many times beyond the levels supported by traditional languages. That’s good news in both boom and bust times, and everywhere the software industry goes in between. Is Python a “Scripting Language”? Python is a general-purpose programming language that is often applied in scripting roles. It is commonly defined as an object-oriented scripting language—a definition that blends support for OOP with an overall orientation toward scripting roles. If pressed for a one-liner, I’d say that Python is probably better known as a general-purpose pro- 1. For a more complete look at the Python philosophy, type the command import this at any Python interactive prompt (you’ll see how in Chapter 3). This invokes an “Easter egg” hidden in Python—a collection of design principles underlying Python that permeate both the language and its user community. Among them, the acronym EIBTI is now fashionable jargon for the “explicit is better than implicit” rule. These principles are not religion, but are close enough to qualify as a Python motto and creed, which we’ll be quoting from often in this book. Is Python a “Scripting Language”? | 5
- 58. gramming language that blends procedural, functional, and object-oriented paradigms— a statement that captures the richness and scope of today’s Python. Still, the term “scripting” seems to have stuck to Python like glue, perhaps as a contrast with larger programming effort required by some other tools. For example, people often use the word “script” instead of “program” to describe a Python code file. In keeping with this tradition, this book uses the terms “script” and “program” interchangeably, with a slight preference for “script” to describe a simpler top-level file and “program” to refer to a more sophisticated multifile application. Because the term “scripting language” has so many different meanings to different observers, though, some would prefer that it not be applied to Python at all. In fact, people tend to make three very different associations, some of which are more useful than others, when they hear Python labeled as such: Shell tools Sometimes when people hear Python described as a scripting language, they think it means that Python is a tool for coding operating-system-oriented scripts. Such programs are often launched from console command lines and perform tasks such as processing text files and launching other programs. Python programs can and do serve such roles, but this is just one of dozens of common Python application domains. It is not just a better shell-script language. Control language To others, scripting refers to a “glue” layer used to control and direct (i.e., script) other application components. Python programs are indeed often deployed in the context of larger applications. For instance, to test hardware devices, Python pro- grams may call out to components that give low-level access to a device. Similarly, programs may run bits of Python code at strategic points to support end-user product customization without the need to ship and recompile the entire system’s source code. Python’s simplicity makes it a naturally flexible control tool. Technically, though, this is also just a common Python role; many (perhaps most) Python programmers code standalone scripts without ever using or knowing about any integrated com- ponents. It is not just a control language. Ease of use Probably the best way to think of the term “scripting language” is that it refers to a simple language used for quickly coding tasks. This is especially true when the term is applied to Python, which allows much faster program development than compiled languages like C++. Its rapid development cycle fosters an exploratory, incremental mode of programming that has to be experienced to be appreciated. Don’t be fooled, though—Python is not just for simple tasks. Rather, it makes tasks simple by its ease of use and flexibility. Python has a simple feature set, but it allows programs to scale up in sophistication as needed. Because of that, it is commonly used for quick tactical tasks and longer-term strategic development. 6 | Chapter 1: A Python Q&A Session
- 59. So, is Python a scripting language or not? It depends on whom you ask. In general, the term “scripting” is probably best used to describe the rapid and flexible mode of de- velopment that Python supports, rather than a particular application domain. OK, but What’s the Downside? After using it for 21 years, writing about it for 18, and teaching it for 16, I’ve found that the only significant universal downside to Python is that, as currently implemented, its execution speed may not always be as fast as that of fully compiled and lower-level languages such as C and C++. Though relatively rare today, for some tasks you may still occasionally need to get “closer to the iron” by using lower-level languages such as these that are more directly mapped to the underlying hardware architecture. We’ll talk about implementation concepts in detail later in this book. In short, the standard implementations of Python today compile (i.e., translate) source code state- ments to an intermediate format known as byte code and then interpret the byte code. Byte code provides portability, as it is a platform-independent format. However, be- cause Python is not normally compiled all the way down to binary machine code (e.g., instructions for an Intel chip), some programs will run more slowly in Python than in a fully compiled language like C. The PyPy system discussed in the next chapter can achieve a 10X to 100X speedup on some code by compiling further as your program runs, but it’s a separate, alternative implementation. Whether you will ever care about the execution speed difference depends on what kinds of programs you write. Python has been optimized numerous times, and Python code runs fast enough by itself in most application domains. Furthermore, whenever you do something “real” in a Python script, like processing a file or constructing a graphical user interface (GUI), your program will actually run at C speed, since such tasks are immediately dispatched to compiled C code inside the Python interpreter. More fun- damentally, Python’s speed-of-development gain is often far more important than any speed-of-execution loss, especially given modern computer speeds. Even at today’s CPU speeds, though, there still are some domains that do require op- timal execution speeds. Numeric programming and animation, for example, often need at least their core number-crunching components to run at C speed (or better). If you work in such a domain, you can still use Python—simply split off the parts of the application that require optimal speed into compiled extensions, and link those into your system for use in Python scripts. We won’t talk about extensions much in this text, but this is really just an instance of the Python-as-control-language role we discussed earlier. A prime example of this dual language strategy is the NumPy numeric programming extension for Python; by com- bining compiled and optimized numeric extension libraries with the Python language, NumPy turns Python into a numeric programming tool that is simultaneously efficient and easy to use. When needed, such extensions provide a powerful optimization tool. OK, but What’s the Downside? | 7
- 60. Other Python Tradeoffs: The Intangible Bits I mentioned that execution speed is the only major downside to Python. That’s indeed the case for most Python users, and especially for newcomers. Most people find Python to be easy to learn and fun to use, especially when compared with its contemporaries like Java, C#, and C++. In the interest of full disclosure, though, I should also note up front some more abstract tradeoffs I’ve observed in my two decades in the Python world —both as an educator and developer. As an educator, I’ve sometimes found the rate of change in Python and its libraries to be a negative, and have on occasion lamented its growth over the years. This is partly because trainers and book authors live on the front lines of such things—it’s been my job to teach the language despite its constant change, a task at times akin to chronicling theherdingofcats!Still,it’sabroadlysharedconcern.Aswe’llseeinthisbook,Python’s original “keep it simple” motif is today often subsumed by a trend toward more so- phisticated solutions at the expense of the learning curve of newcomers. This book’s size is indirect evidence of this trend. On the other hand, by most measures Python is still much simpler than its alternatives, and perhaps only as complex as it needs to be given the many roles it serves today. Its overall coherence and open nature remain compelling features to most. Moreover, not everyone needs to stay up to date with the cutting edge—as Python 2.X’s ongoing popularity clearly shows. As a developer, I also at times question the tradeoffs inherent in Python’s “batteries included” approach to development. Its emphasis on prebuilt tools can add dependen- cies (what if a battery you use is changed, broken, or deprecated?), and encourage special-case solutions over general principles that may serve users better in the long run (how can you evaluate or use a tool well if you don’t understand its purpose?). We’ll see examples of both of these concerns in this book. For typical users, and especially for hobbyists and beginners, Python’s toolset approach is a major asset. But you shouldn’t be surprised when you outgrow precoded tools, and can benefit from the sorts of skills this book aims to impart. Or, to paraphrase a proverb: give people a tool, and they’ll code for a day; teach them how to build tools, and they’ll code for a lifetime. This book’s job is more the latter than the former. As mentioned elsewhere in this chapter, both Python and its toolbox model are also susceptible to downsides common to open source projects in general—the potential triumph of the personal preference of the few over common usage of the many, and the occasional appearance of anarchy and even elitism—though these tend to be most grievous on the leading edge of new releases. We’ll return to some of these tradeoffs at the end of the book, after you’ve learned Python well enough to draw your own conclusions. As an open source system, what Python “is” is up to its users to define. In the end, Python is more popular today than ever, and its growth shows no signs of abating. To some, that may be a more telling metric than individual opinions, both pro and con. 8 | Chapter 1: A Python Q&A Session
- 61. Who Uses Python Today? At this writing, the best estimate anyone can seem to make of the size of the Python user base is that there are roughly 1 million Python users around the world today (plus or minus a few). This estimate is based on various statistics, like download rates, web statistics, and developer surveys. Because Python is open source, a more exact count is difficult—there are no license registrations to tally. Moreover, Python is automatically included with Linux distributions, Macintosh computers, and a wide range of products and hardware, further clouding the user-base picture. In general, though, Python enjoys a large user base and a very active developer com- munity. It is generally considered to be in the top 5 or top 10 most widely used pro- gramming languages in the world today (its exact ranking varies per source and date). Because Python has been around for over two decades and has been widely used, it is also very stable and robust. Besides being leveraged by individual users, Python is also being applied in real revenue- generating products by real companies. For instance, among the generally known Python user base: • Google makes extensive use of Python in its web search systems. • The popular YouTube video sharing service is largely written in Python. • The Dropbox storage service codes both its server and desktop client software pri- marily in Python. • The Raspberry Pi single-board computer promotes Python as its educational lan- guage. • EVE Online, a massively multiplayer online game (MMOG) by CCP Games, uses Python broadly. • The widespread BitTorrent peer-to-peer file sharing system began its life as a Python program. • Industrial Light & Magic, Pixar, and others use Python in the production of ani- mated movies. • ESRI uses Python as an end-user customization tool for its popular GIS mapping products. • Google’s App Engine web development framework uses Python as an application language. • The IronPort email server product uses more than 1 million lines of Python code to do its job. • Maya, a powerful integrated 3D modeling and animation system, provides a Python scripting API. • The NSA uses Python for cryptography and intelligence analysis. • iRobot uses Python to develop commercial and military robotic devices. Who Uses Python Today? | 9
- 62. • The Civilization IV game’s customizable scripted events are written entirely in Python. • TheOneLaptopPerChild(OLPC)projectbuiltitsuserinterfaceandactivitymodel in Python. • Netflix and Yelp have both documented the role of Python in their software infra- structures. • Intel, Cisco, Hewlett-Packard, Seagate, Qualcomm, and IBM use Python for hard- ware testing. • JPMorgan Chase, UBS, Getco, and Citadel apply Python to financial market fore- casting. • NASA, Los Alamos, Fermilab, JPL, and others use Python for scientific program- ming tasks. And so on—though this list is representative, a full accounting is beyond this book’s scope, and is almost guaranteed to change over time. For an up-to-date sampling of additional Python users, applications, and software, try the following pages currently at Python’s site and Wikipedia, as well as a search in your favorite web browser: • Success stories: http://www.python.org/about/success • Application domains: http://www.python.org/about/apps • User quotes: http://www.python.org/about/quotes • Wikipedia page: http://en.wikipedia.org/wiki/List_of_Python_software Probably the only common thread among the companies using Python today is that Python is used all over the map, in terms of application domains. Its general-purpose nature makes it applicable to almost all fields, not just one. In fact, it’s safe to say that virtually every substantial organization writing software is using Python, whether for short-term tactical tasks, such as testing and administration, or for long-term strategic product development. Python has proven to work well in both modes. What Can I Do with Python? In addition to being a well-designed programming language, Python is useful for ac- complishing real-world tasks—the sorts of things developers do day in and day out. It’s commonly used in a variety of domains, as a tool for scripting other components and implementing standalone programs. In fact, as a general-purpose language, Python’s roles are virtually unlimited: you can use it for everything from website de- velopment and gaming to robotics and spacecraft control. However, the most common Python roles currently seem to fall into a few broad cat- egories. The next few sections describe some of Python’s most common applications today, as well as tools used in each domain. We won’t be able to explore the tools 10 | Chapter 1: A Python Q&A Session
- 63. mentioned here in any depth—if you are interested in any of these topics, see the Python website or other resources for more details. Systems Programming Python’s built-in interfaces to operating-system services make it ideal for writing portable, maintainable system-administration tools and utilities (sometimes calledshell tools). Python programs can search files and directory trees, launch other programs, do parallel processing with processes and threads, and so on. Python’s standard library comes with POSIX bindings and support for all the usual OS tools: environment variables, files, sockets, pipes, processes, multiple threads, regular expression pattern matching, command-line arguments, standard stream interfaces, shell-command launchers, filename expansion, zip file utilities, XML and JSON pars- ers, CSV file handlers, and more. In addition, the bulk of Python’s system interfaces are designed to be portable; for example, a script that copies directory trees typically runs unchanged on all major Python platforms. The Stackless Python implementation, described in Chapter 2 and used by EVE Online, also offers advanced solutions to multiprocessing requirements. GUIs Python’s simplicity and rapid turnaround also make it a good match for graphical user interface programming on the desktop. Python comes with a standard object-oriented interface to the Tk GUI API called tkinter (Tkinter in 2.X) that allows Python programs to implement portable GUIs with a native look and feel. Python/tkinter GUIs run un- changed on Microsoft Windows, X Windows (on Unix and Linux), and the Mac OS (both Classic and OS X). A free extension package, PMW, adds advanced widgets to the tkinter toolkit. In addition, the wxPython GUI API, based on a C++ library, offers an alternative toolkit for constructing portable GUIs in Python. Higher-level toolkits such as Dabo are built on top of base APIs such as wxPython and tkinter. With the proper library, you can also use GUI support in other toolkits in Python, such as Qt with PyQt, GTK with PyGTK, MFC with PyWin32, .NET with IronPython, and Swing with Jython (the Java version of Python, described in Chap- ter 2) or JPype. For applications that run in web browsers or have simple interface requirements, both Jython and Python web frameworks and server-side CGI scripts, described in the next section, provide additional user interface options. Internet Scripting Python comes with standard Internet modules that allow Python programs to perform a wide variety of networking tasks, in client and server modes. Scripts can communicate over sockets; extract form information sent to server-side CGI scripts; transfer files by FTP; parse and generate XML and JSON documents; send, receive, compose, and parse What Can I Do with Python? | 11
- 64. email; fetch web pages by URLs; parse the HTML of fetched web pages; communicate over XML-RPC, SOAP, and Telnet; and more. Python’s libraries make these tasks re- markably simple. In addition, a large collection of third-party tools are available on the Web for doing Internet programming in Python. For instance, the HTMLGen system generates HTML files from Python class-based descriptions, the mod_python package runs Python effi- ciently within the Apache web server and supports server-side templating with its Python Server Pages, and the Jython system provides for seamless Python/Java inte- gration and supports coding of server-side applets that run on clients. In addition, full-blown web development framework packages for Python, such as Django, TurboGears, web2py, Pylons, Zope, and WebWare, support quick construction of full-featured and production-quality websites with Python. Many of these include features such as object-relational mappers, a Model/View/Controller architecture, server-side scripting and templating, and AJAX support, to provide complete and en- terprise-level web development solutions. More recently, Python has expanded into rich Internet applications (RIAs), with tools such as Silverlight in IronPython, and pyjs (a.k.a. pyjamas) and its Python-to-JavaScript compiler, AJAX framework, and widget set. Python also has moved into cloud com- puting, with App Engine, and others described in the database section ahead. Where the Web leads, Python quickly follows. Component Integration We discussed the component integration role earlier when describing Python as a con- trol language. Python’s ability to be extended by and embedded in C and C++ systems makes it useful as a flexible glue language for scripting the behavior of other systems and components. For instance, integrating a C library into Python enables Python to test and launch the library’s components, and embedding Python in a product enables onsite customizations to be coded without having to recompile the entire product (or ship its source code at all). Tools such as the SWIG and SIP code generators can automate much of the work needed to link compiled components into Python for use in scripts, and the Cython system allows coders to mix Python and C-like code. Larger frameworks, such as Python’s COM support on Windows, the Jython Java-based implementation, and the IronPython .NET-based implementation provide alternative ways to script compo- nents. On Windows, for example, Python scripts can use frameworks to script Word and Excel, access Silverlight, and much more. Database Programming For traditional database demands, there are Python interfaces to all commonly used relational database systems—Sybase, Oracle, Informix, ODBC, MySQL, PostgreSQL, 12 | Chapter 1: A Python Q&A Session
- 65. SQLite, and more. The Python world has also defined a portable database API for ac- cessing SQL database systems from Python scripts, which looks the same on a variety of underlying database systems. For instance, because the vendor interfaces implement the portable API, a script written to work with the free MySQL system will work largely unchanged on other systems (such as Oracle); all you generally have to do is replace the underlying vendor interface. The in-processSQLite embedded SQL database engine is a standard part of Python itself since 2.5, supporting both prototyping and basic program storage needs. In the non-SQL department, Python’s standard pickle module provides a simple object persistence system—it allows programs to easily save and restore entire Python objects to files and file-like objects. On the Web, you’ll also find third-party open source sys- tems named ZODB and Durus that provide complete object-oriented database systems for Python scripts; others, such as SQLObject and SQLAlchemy, that implement object relational mappers (ORMs), which graft Python’s class model onto relational tables; and PyMongo, an interface to MongoDB, a high-performance, non-SQL, open source JSON-style document database, which stores data in structures very similar to Python’s own lists and dictionaries, and whose text may be parsed and created with Python’s own standard library json module. Still other systems offer more specialized ways to store data, including the datastore in Google’s App Engine, which models data with Python classes and provides extensive scalability, as well as additional emerging cloud storage options such as Azure, Pi- Cloud, OpenStack, and Stackato. Rapid Prototyping To Python programs, components written in Python and C look the same. Because of this, it’s possible to prototype systems in Python initially, and then move selected com- ponents to a compiled language such as C or C++ for delivery. Unlike some prototyping tools, Python doesn’t require a complete rewrite once the prototype has solidified. Parts of the system that don’t require the efficiency of a language such as C++ can remain coded in Python for ease of maintenance and use. Numeric and Scientific Programming Python is also heavily used in numeric programming—a domain that would not tra- ditionally have been considered to be in the scope of scripting languages, but has grown to become one of Python’s most compelling use cases. Prominent here, the NumPy high-performance numeric programming extension for Python mentioned earlier in- cludes such advanced tools as an array object, interfaces to standard mathematical libraries, and much more. By integrating Python with numeric routines coded in a compiled language for speed, NumPy turns Python into a sophisticated yet easy-to-use numeric programming tool that can often replace existing code written in traditional compiled languages such as FORTRAN or C++. What Can I Do with Python? | 13
- 66. Additional numeric tools for Python support animation, 3D visualization, parallel pro- cessing, and so on. The popular SciPy and ScientificPython extensions, for example, provide additional libraries of scientific programming tools and use NumPy as a core component. The PyPy implementation of Python (discussed in Chapter 2) has also gained traction in the numeric domain, in part because heavily algorithmic code of the sort that’s common in this domain can run dramatically faster in PyPy—often 10X to 100X quicker. And More: Gaming, Images, Data Mining, Robots, Excel... Python is commonly applied in more domains than can be covered here. For example, you’ll find tools that allow you to use Python to do: • Game programming and multimedia with pygame, cgkit, pyglet, PySoy, Panda3D, and others • Serial port communication on Windows, Linux, and more with the PySerial ex- tension • Image processing with PIL and its newer Pillow fork, PyOpenGL, Blender, Maya, and more • Robot control programming with the PyRo toolkit • Natural language analysis with the NLTK package • Instrumentation on the Raspberry Pi and Arduino boards • Mobile computing with ports of Python to the Google Android and Apple iOS platforms • Excel spreadsheet function and macro programming with the PyXLL or DataNi- tro add-ins • Media file content and metadata tag processing with PyMedia, ID3, PIL/Pillow, and more • Artificial intelligence with the PyBrain neural net library and the Milk machine learning toolkit • Expert system programming with PyCLIPS, Pyke, Pyrolog, and pyDatalog • Network monitoring with zenoss, written in and customized with Python • Python-scripted design and modeling with PythonCAD, PythonOCC, FreeCAD, and others • Document processing and generation with ReportLab, Sphinx, Cheetah, PyPDF, and so on • Data visualization with Mayavi, matplotlib, VTK, VPython, and more • XML parsing with the xml library package, the xmlrpclib module, and third-party extensions • JSON and CSV file processing with the json and csv modules 14 | Chapter 1: A Python Q&A Session
- 67. • Data mining with the Orange framework, the Pattern bundle, Scrapy, and custom code You can even play solitaire with the PySolFC program. And of course, you can always code custom Python scripts in less buzzword-laden domains to perform day-to-day system administration, process your email, manage your document and media libraries, and so on. You’ll find links to the support in many fields at the PyPI website, and via web searches (search Google or http://www.python.org for links). Though of broad practical use, many of these specific domains are largely just instances of Python’s component integration role in action again. Adding it as a frontend to libraries of components written in a compiled language such as C makes Python useful for scripting in a wide variety of domains. As a general-purpose language that supports integration, Python is widely applicable. How Is Python Developed and Supported? As a popular open source system, Python enjoys a large and active development com- munity that responds to issues and develops enhancements with a speed that many commercial software developers might find remarkable. Python developers coordinate work online with a source-control system. Changes are developed per a formal proto- col, which includes writing a PEP (Python Enhancement Proposal) or other document, and extensions to Python’s regression testing system. In fact, modifying Python today is roughly as involved as changing commercial software—a far cry from Python’s early days, when an email to its creator would suffice, but a good thing given its large user base today. The PSF (Python Software Foundation), a formal nonprofit group, organizes confer- ences and deals with intellectual property issues. Numerous Python conferences are held around the world; O’Reilly’s OSCON and the PSF’s PyCon are the largest. The former of these addresses multiple open source projects, and the latter is a Python-only event that has experienced strong growth in recent years. PyCon 2012 and 2013 reached 2,500 attendees each; in fact, PyCon 2013 had to cap its limit at this level after a surprise sell-out in 2012 (and managed to grab wide attention on both technical and nontech- nical grounds that I won’t chronicle here). Earlier years often saw attendance double —from 586 attendees in 2007 to over 1,000 in 2008, for example—indicative of Python’s growth in general, and impressive to those who remember early conferences whose attendees could largely be served around a single restaurant table. Open Source Tradeoffs Having said that, it’s important to note that while Python enjoys a vigorous develop- ment community, this comes with inherent tradeoffs. Open source software can also appear chaotic and even resemble anarchy at times, and may not always be as smoothly implemented as the prior paragraphs might imply. Some changes may still manage to How Is Python Developed and Supported? | 15
- 68. defy official protocols, and as in all human endeavors, mistakes still happen despite the process controls (Python 3.2.0, for instance, came with a broken console input function on Windows). Moreover, open source projects exchange commercial interests for the personal pref- erences of a current set of developers, which may or may not be the same as yours— you are not held hostage by a company, but you are at the mercy of those with spare time to change the system. The net effect is that open source software evolution is often driven by the few, but imposed on the many. In practice, though, these tradeoffs impact those on the “bleeding” edge of new releases much more than those using established versions of the system, including prior releases in both Python 3.X and 2.X. If you kept using classic classes in Python 2.X, for example, you were largely immune to the explosion of class functionality and change in new-style classes that occurred in the early-to-mid 2000s. Though these become mandatory in 3.X (along with much more), many 2.X users today still happily skirt the issue. What Are Python’s Technical Strengths? Naturally, this is a developer’s question. If you don’t already have a programming background, the language in the next few sections may be a bit baffling—don’t worry, we’ll explore all of these terms in more detail as we proceed through this book. For developers, though, here is a quick introduction to some of Python’s top technical features. It’s Object-Oriented and Functional Python is an object-oriented language, from the ground up. Its class model supports advanced notions such as polymorphism, operator overloading, and multiple inheri- tance; yet, in the context of Python’s simple syntax and typing, OOP is remarkably easy to apply. In fact, if you don’t understand these terms, you’ll find they are much easier to learn with Python than with just about any other OOP language available. Besides serving as a powerful code structuring and reuse device, Python’s OOP nature makes it ideal as a scripting tool for other object-oriented systems languages. For ex- ample, with the appropriate glue code, Python programs can subclass (specialize) classes implemented in C++, Java, and C#. Of equal significance, OOP is an option in Python; you can go far without having to become an object guru all at once. Much like C++, Python supports both procedural and object-oriented programming modes. Its object-oriented tools can be applied if and when constraints allow. This is especially useful in tactical development modes, which preclude design phases. In addition to its original procedural (statement-based) and object-oriented (class- based) paradigms, Python in recent years has acquired built-in support for functional 16 | Chapter 1: A Python Q&A Session
- 69. programming—a set that by most measures includes generators, comprehensions, clo- sures, maps, decorators, anonymous function lambdas, and first-class function objects. These can serve as both complement and alternative to its OOP tools. It’s Free Python is completely free to use and distribute. As with other open source software, such as Tcl, Perl, Linux, and Apache, you can fetch the entire Python system’s source code for free on the Internet. There are no restrictions on copying it, embedding it in your systems, or shipping it with your products. In fact, you can even sell Python’s source code, if you are so inclined. But don’t get the wrong idea: “free” doesn’t mean “unsupported.” On the contrary, the Python online community responds to user queries with a speed that most com- mercial software help desks would do well to try to emulate. Moreover, because Python comes with complete source code, it empowers developers, leading to the creation of a large team of implementation experts. Although studying or changing a programming language’s implementation isn’t everyone’s idea of fun, it’s comforting to know that you can do so if you need to. You’re not dependent on the whims of a commercial vendor, because the ultimate documentation—source code—is at your disposal as a last resort. As mentioned earlier, Python development is performed by a community that largely coordinates its efforts over the Internet. It consists of Python’s original creator—Guido van Rossum, the officially anointed Benevolent Dictator for Life (BDFL) of Python— plus a supporting cast of thousands. Language changes must follow a formal enhance- ment procedure and be scrutinized by both other developers and the BDFL. This tends to make Python more conservative with changes than some other languages and sys- tems. While the Python 3.X/2.X split broke with this tradition soundly and deliberately, it still holds generally true within each Python line. It’s Portable The standard implementation of Python is written in portable ANSI C, and it compiles and runs on virtually every major platform currently in use. For example, Python pro- grams run today on everything from PDAs to supercomputers. As a partial list, Python is available on: • Linux and Unix systems • Microsoft Windows (all modern flavors) • Mac OS (both OS X and Classic) • BeOS, OS/2, VMS, and QNX • Real-time systems such as VxWorks • Cray supercomputers and IBM mainframes What Are Python’s Technical Strengths? | 17
- 70. • PDAs running Palm OS, PocketPC, and Linux • Cell phones running Symbian OS, and Windows Mobile • Gaming consoles and iPods • Tablets and smartphones running Google’s Android and Apple’s iOS • And more Like the language interpreter itself, the standard library modules that ship with Python are implemented to be as portable across platform boundaries as possible. Further, Python programs are automatically compiled to portable byte code, which runs the same on any platform with a compatible version of Python installed (more on this in the next chapter). WhatthatmeansisthatPythonprogramsusingthecorelanguageandstandardlibraries run the same on Linux, Windows, and most other systems with a Python interpreter. Most Python ports also contain platform-specific extensions (e.g., COM support on Windows), but the core Python language and libraries work the same everywhere. As mentioned earlier, Python also includes an interface to the Tk GUI toolkit called tkinter (Tkinter in 2.X), which allows Python programs to implement full-featured graphical user interfaces that run on all major GUI desktop platforms without program changes. It’s Powerful From a features perspective, Python is something of a hybrid. Its toolset places it be- tween traditional scripting languages (such as Tcl, Scheme, and Perl) and systems de- velopment languages (such as C, C++, and Java). Python provides all the simplicity and ease of use of a scripting language, along with more advanced software-engineering tools typically found in compiled languages. Unlike some scripting languages, this combination makes Python useful for large-scale development projects. As a preview, here are some of the main things you’ll find in Python’s toolbox: Dynamic typing Python keeps track of the kinds of objects your program uses when it runs; it doesn’t require complicated type and size declarations in your code. In fact, as you’ll see in Chapter 6, there is no such thing as a type or variable declaration anywhere in Python. Because Python code does not constrain data types, it is also usually automatically applicable to a whole range of objects. Automatic memory management Python automatically allocates objects and reclaims (“garbage collects”) them when they are no longer used, and most can grow and shrink on demand. As you’ll learn, Python keeps track of low-level memory details so you don’t have to. Programming-in-the-large support For building larger systems, Python includes tools such as modules, classes, and exceptions. These tools allow you to organize systems into components, use OOP 18 | Chapter 1: A Python Q&A Session
- 71. to reuse and customize code, and handle events and errors gracefully. Python’s functional programming tools, described earlier, provide additional ways to meet many of the same goals. Built-in object types Python provides commonly used data structures such as lists, dictionaries, and strings as intrinsic parts of the language; as you’ll see, they’re both flexible and easy to use. For instance, built-in objects can grow and shrink on demand, can be ar- bitrarily nested to represent complex information, and more. Built-in tools To process all those object types, Python comes with powerful and standard op- erations, including concatenation (joining collections), slicing (extracting sec- tions), sorting, mapping, and more. Library utilities For more specific tasks, Python also comes with a large collection of precoded library tools that support everything from regular expression matching to net- working. Once you learn the language itself, Python’s library tools are where much of the application-level action occurs. Third-party utilities Because Python is open source, developers are encouraged to contribute precoded tools that support tasks beyond those supported by its built-ins; on the Web, you’ll find free support for COM, imaging, numeric programming, XML, database ac- cess, and much more. Despite the array of tools in Python, it retains a remarkably simple syntax and design. The result is a powerful programming tool with all the usability of a scripting language. It’s Mixable Python programs can easily be “glued” to components written in other languages in a variety of ways. For example, Python’s C API lets C programs call and be called by Python programs flexibly. That means you can add functionality to the Python system as needed, and use Python programs within other environments or systems. Mixing Python with libraries coded in languages such as C or C++, for instance, makes it an easy-to-use frontend language and customization tool. As mentioned earlier, this also makes Python good at rapid prototyping—systems may be implemented in Python first, to leverage its speed of development, and later moved to C for delivery, one piece at a time, according to performance demands. It’s Relatively Easy to Use Compared to alternatives like C++, Java, and C#, Python programming seems aston- ishingly simple to most observers. To run a Python program, you simply type it and run it. There are no intermediate compile and link steps, like there are for languages What Are Python’s Technical Strengths? | 19
- 72. such as C or C++. Python executes programs immediately, which makes for an inter- active programming experience and rapid turnaround after program changes—in many cases, you can witness the effect of a program change nearly as fast as you can type it. Of course, development cycle turnaround is only one aspect of Python’s ease of use. It also provides a deliberately simple syntax and powerful built-in tools. In fact, some have gone so far as to call Python executable pseudocode. Because it eliminates much of the complexity in other tools, Python programs are simpler, smaller, and more flex- ible than equivalent programs in other popular languages. It’s Relatively Easy to Learn This brings us to the point of this book: especially when compared to other widely used programming languages, the core Python language is remarkably easy to learn. In fact, if you’re an experienced programmer, you can expect to be coding small-scale Python programs in a matter of days, and may be able to pick up some limited portions of the language in just hours—though you shouldn’t expect to become an expert quite that fast (despite what you may have heard from marketing departments!). Naturally, mastering any topic as substantial as today’s Python is not trivial, and we’ll devote the rest of this book to this task. But the true investment required to master Python is worthwhile—in the end, you’ll gain programming skills that apply to nearly every computer application domain. Moreover, most find Python’s learning curve to be much gentler than that of other programming tools. That’s good news for professional developers seeking to learn the language to use on the job, as well as for end users of systems that expose a Python layer for customization or control. Today, many systems rely on the fact that end users can learn enough Python to tailor their Python customization code onsite, with little or no support. Moreover, Python has spawned a large group of users who program for fun instead of career, and may never need full-scale software development skills. Although Python does have advanced programming tools, its core language essentials will still seem relatively sim- ple to beginners and gurus alike. It’s Named After Monty Python OK, this isn’t quite a technical strength, but it does seem to be a surprisingly well-kept secret in the Python world that I wish to expose up front. Despite all the reptiles on Python books and icons, the truth is that Python is named after the British comedy group Monty Python—makers of the 1970s BBC comedy series Monty Python’s Flying Circus and a handful of later full-length films, including Monty Python and the Holy Grail, that are still widely popular today. Python’s original creator was a fan of Monty Python, as are many software developers (indeed, there seems to be a sort of symmetry between the two fields...). 20 | Chapter 1: A Python Q&A Session
- 73. This legacy inevitably adds a humorous quality to Python code examples. For instance, the traditional “foo” and “bar” for generic variable names become “spam” and “eggs” in the Python world. The occasional “Brian,” “ni,” and “shrubbery” likewise owe their appearances to this namesake. It even impacts the Python community at large: some events at Python conferences are regularly billed as “The Spanish Inquisition.” All of this is, of course, very funny if you are familiar with the shows, but less so other- wise. You don’t need to be familiar with Monty Python’s work to make sense of ex- amples that borrow references from it, including many you will see in this book, but at least you now know their root. (Hey—I’ve warned you.) How Does Python Stack Up to Language X? Finally, to place it in the context of what you may already know, people sometimes compare Python to languages such as Perl, Tcl, and Java. This section summarizes common consensus in this department. I want to note up front that I’m not a fan of winning by disparaging the competition— it doesn’t work in the long run, and that’s not the goal here. Moreover, this is not a zero sum game—most programmers will use many languages over their careers. Nev- ertheless, programming tools present choices and tradeoffs that merit consideration. After all, if Python didn’t offer something over its alternatives, it would never have been used in the first place. We talked about performance tradeoffs earlier, so here we’ll focus on functionality. While other languages are also useful tools to know and use, many people find that Python: • Is more powerful than Tcl. Python’s strong support for “programming in the large” makes it applicable to the development of larger systems, and its library of appli- cation tools is broader. • Is more readable than Perl. Python has a clear syntax and a simple, coherent design. This in turn makes Python more reusable and maintainable, and helps reduce pro- gram bugs. • Is simpler and easier to use than Java and C#. Python is a scripting language, but Java and C# both inherit much of the complexity and syntax of larger OOP systems languages like C++. • Is simpler and easier to use than C++. Python code is simpler than the equivalent C++ and often one-third to one-fifth as large, though as a scripting language, Python sometimes serves different roles. • Is simpler and higher-level than C. Python’s detachment from underlying hardware architecture makes code less complex, better structured, and more approachable than C, C++’s progenitor. How Does Python Stack Up to Language X? | 21
- 74. • Is more powerful, general-purpose, and cross-platform than Visual Basic. Python is a richer language that is used more widely, and its open source nature means it is not controlled by a single company. • Is more readable and general-purpose than PHP. Python is used to construct web- sitestoo,butitisalsoappliedtonearlyeveryothercomputerdomain,fromrobotics to movie animation and gaming. • Is more powerful and general-purpose than JavaScript. Python has a larger toolset, and is not as tightly bound to web development. It’s also used for scientific mod- eling, instrumentation, and more. • Is more readable and established than Ruby. Python syntax is less cluttered, espe- cially in nontrivial code, and its OOP is fully optional for users and projects to which it may not apply. • Is more mature and broadly focused than Lua. Python’s larger feature set and more extensive library support give it a wider scope than Lua, an embedded “glue” lan- guage like Tcl. • Is less esoteric than Smalltalk, Lisp, and Prolog. Python has the dynamic flavor of languages like these, but also has a traditional syntax accessible to both developers and end users of customizable systems. Especially for programs that do more than scan text files, and that might have to be read in the future by others (or by you!), many people find that Python fits the bill better than any other scripting or programming language available today. Furthermore, unless your application requires peak performance, Python is often a viable alternative to systems development languages such as C, C++, and Java: Python code can often ach- ieve the same goals, but will be much less difficult to write, debug, and maintain. Of course, your author has been a card-carrying Python evangelist since 1992, so take these comments as you may (and other languages’ advocates’ mileage may vary arbi- trarily). They do, however, reflect the common experience of many developers who have taken time to explore what Python has to offer. Chapter Summary And that concludes the “hype” portion of this book. In this chapter, we’ve explored some of the reasons that people pick Python for their programming tasks. We’ve also seen how it is applied and looked at a representative sample of who is using it today. My goal is to teach Python, though, not to sell it. The best way to judge a language is to see it in action, so the rest of this book focuses entirely on the language details we’ve glossed over here. The next two chapters begin our technical introduction to the language. In them, we’ll explore ways to run Python programs, peek at Python’s byte code execution model, and introduce the basics of module files for saving code. The goal will be to give you 22 | Chapter 1: A Python Q&A Session
- 75. just enough information to run the examples and exercises in the rest of the book. You won’t really start programming per se until Chapter 4, but make sure you have a handle on the startup details before moving on. Test Your Knowledge: Quiz In this edition of the book, we will be closing each chapter with a quick open-book quiz about the material presented herein to help you review the key concepts. The answers for these quizzes appear immediately after the questions, and you are encour- aged to read the answers once you’ve taken a crack at the questions yourself, as they sometimes give useful context. In addition to these end-of-chapter quizzes, you’ll find lab exercises at the end of each part of the book, designed to help you start coding Python on your own. For now, here’s your first quiz. Good luck, and be sure to refer back to this chapter’s material as needed. 1. What are the six main reasons that people choose to use Python? 2. Name four notable companies or organizations using Python today. 3. Why might you not want to use Python in an application? 4. What can you do with Python? 5. What’s the significance of the Python import this statement? 6. Why does “spam” show up in so many Python examples in books and on the Web? 7. What is your favorite color? Test Your Knowledge: Answers How did you do? Here are the answers I came up with, though there may be multiple solutions to some quiz questions. Again, even if you’re sure of your answer, I encourage you to look at mine for additional context. See the chapter’s text for more details if any of these responses don’t make sense to you. 1. Software quality, developer productivity, program portability, support libraries, component integration, and simple enjoyment. Of these, the quality and produc- tivity themes seem to be the main reasons that people choose to use Python. 2. Google, Industrial Light & Magic, CCP Games, Jet Propulsion Labs, Maya, ESRI, and many more. Almost every organization doing software development uses Python in some fashion, whether for long-term strategic product development or for short-term tactical tasks such as testing and system administration. 3. Python’s main downside is performance: it won’t run as quickly as fully compiled languages like C and C++. On the other hand, it’s quick enough for most appli- cations, and typical Python code runs at close to C speed anyhow because it invokes Test Your Knowledge: Answers | 23
- 76. linked-in C code in the interpreter. If speed is critical, compiled extensions are available for number-crunching parts of an application. 4. You can use Python for nearly anything you can do with a computer, from website development and gaming to robotics and spacecraft control. 5. This was mentioned in a footnote: import this triggers an Easter egg inside Python that displays some of the design philosophies underlying the language. You’ll learn how to run this statement in the next chapter. 6. “Spam” is a reference from a famous Monty Python skit in which people trying to order food in a cafeteria are drowned out by a chorus of Vikings singing about spam. Oh, and it’s also a common variable name in Python scripts... 7. Blue. No, yellow! (See the prior answer.) Python Is Engineering, Not Art When Python first emerged on the software scene in the early 1990s, it spawned what is now something of a classic conflict between its proponents and those of another popular scripting language, Perl. Personally, I think the debate is tired and unwarranted today—developers are smart enough to draw their own conclusions. Still, this is one of the most common topics I’m asked about on the training road, and underscores one of the main reasons people choose to use Python; it seems fitting to say a few brief words about it here. The short story is this: you can do everything in Python that you can in Perl, but you can read your code after you do it. That’s it—their domains largely overlap, but Python is more focused on producing readable code. For many, the enhanced readability of Python translates to better code reusability and maintainability, making Python a better choice for programs that will not be written once and thrown away. Perl code is easy to write, but can be difficult to read. Given that most software has a lifespan much longer than its initial creation, many see Python as the more effective tool. The somewhat longer story reflects the backgrounds of the designers of the two lan- guages. Python originated with a mathematician by training, who seems to have natu- rally produced an orthogonal language with a high degree of uniformity and coherence. Perl was spawned by a linguist, who created a programming tool closer to natural language, with its context sensitivities and wide variability. As a well-known Perl motto states, there’s more than one way to do it. Given this mindset, both the Perl language and its user community have historically encouraged untethered freedom of expression when writing code. One person’s Perl code can be radically different from another’s. In fact, writing unique, tricky code is often a source of pride among Perl users. But as anyone who has done any substantial code maintenance should be able to attest, freedom of expression is great for art, but lousy for engineering. In engineering, we need a minimal feature set and predictability. In engineering, freedom of expression can lead to maintenance nightmares. As more than one Perl user has confided to me, the result of too much freedom is often code that is much easier to rewrite from scratch than to modify. This is clearly less than ideal. 24 | Chapter 1: A Python Q&A Session
- 77. Consider this: when people create a painting or a sculpture, they do so largely for themselves; the prospect of someone else changing their work later doesn’t enter into it. This is a critical difference between art and engineering. When people write soft- ware, they are not writing it for themselves. In fact, they are not even writing primarily for the computer. Rather, good programmers know that code is written for the next human being who has to read it in order to maintain or reuse it. If that person cannot understand the code, it’s all but useless in a realistic development scenario. In other words, programming is not about being clever and obscure—it’s about how clearly your program communicates its purpose. This readability focus is where many people find that Python most clearly differentiates itself from other scripting languages. Because Python’s syntax model almost forces the creation of readable code, Python programs lend themselves more directly to the full software development cycle. And because Python emphasizes ideas such as limited interactions, code uniformity, and feature consistency, it more directly fosters code that can be used long after it is first written. In the long run, Python’s focus oncode quality in itself boosts programmer productivity, as well as programmer satisfaction. Python programmers can be wildly creative, too, of course, and as we’ll see, the language does offer multiple solutions for some tasks— sometimes even more than it should today, an issue we’ll confront head-on in this book too. In fact, this sidebar can also be read as a cautionary tale: quality turns out to be a fragile state, one that depends as much on people as on technology. Python has histor- ically encouraged good engineering in ways that other scripting languages often did not, but the rest of the quality story is up to you. At least, that’s some of the common consensus among many people who have adopted Python. You should judge such claims for yourself, of course, by learning what Python has to offer. To help you get started, let’s move on to the next chapter. Test Your Knowledge: Answers | 25
- 79. CHAPTER 2 How Python Runs Programs This chapter and the next take a quick look at program execution—how you launch code, and how Python runs it. In this chapter, we’ll study how the Python interpreter executes programs in general. Chapter 3 will then show you how to get your own programs up and running. Startup details are inherently platform-specific, and some of the material in these two chapters may not apply to the platform you work on, so more advanced readers should feel free to skip parts not relevant to their intended use. Likewise, readers who have used similar tools in the past and prefer to get to the meat of the language quickly may want to file some of these chapters away as “for future reference.” For the rest of us, let’s take a brief look at the way that Python will run our code, before we learn how to write it. Introducing the Python Interpreter So far, I’ve mostly been talking about Python as a programming language. But, as cur- rently implemented, it’s also a software package called an interpreter. An interpreter is a kind of program that executes other programs. When you write a Python program, the Python interpreter reads your program and carries out the instructions it contains. In effect, the interpreter is a layer of software logic between your code and the computer hardware on your machine. When the Python package is installed on your machine, it generates a number of com- ponents—minimally, an interpreter and a support library. Depending on how you use it, the Python interpreter may take the form of an executable program, or a set of libraries linked into another program. Depending on which flavor of Python you run, the interpreter itself may be implemented as a C program, a set of Java classes, or something else. Whatever form it takes, the Python code you write must always be run by this interpreter. And to enable that, you must install a Python interpreter on your computer. 27
- 80. Python installation details vary by platform and are covered in more depth in Appen- dix A. In short: • Windows users fetch and run a self-installing executable file that puts Python on their machines. Simply double-click and say Yes or Next at all prompts. • Linux and Mac OS X users probably already have a usable Python preinstalled on their computers—it’s a standard component on these platforms today. • Some Linux and Mac OS X users (and most Unix users) compile Python from its full source code distribution package. • Linux users can also find RPM files, and Mac OS X users can find various Mac- specific installation packages. • Other platforms have installation techniques relevant to those platforms. For in- stance, Python is available on cell phones, tablets, game consoles, and iPods, but installation details vary widely. Python itself may be fetched from the downloads page on its main website, http://www .python.org. It may also be found through various other distribution channels. Keep in mind that you should always check to see whether Python is already present before installing it. If you’re working on Windows 7 and earlier, you’ll usually find Python in the Start menu, as captured in Figure 2-1; we’ll discuss the menu options shown here in the next chapter. On Unix and Linux, Python probably lives in your /usr directory tree. Because installation details are so platform-specific, we’ll postpone the rest of this story here. For more details on the installation process, consult Appendix A. For the purposes of this chapter and the next, I’ll assume that you’ve got Python ready to go. Program Execution What it means to write and run a Python script depends on whether you look at these tasks as a programmer, or as a Python interpreter. Both views offer important perspec- tives on Python programming. The Programmer’s View In its simplest form, a Python program is just a text file containing Python statements. For example, the following file, named script0.py, is one of the simplest Python scripts I could dream up, but it passes for a fully functional Python program: print('hello world') print(2 ** 100) This file contains two Python print statements, which simply print a string (the text in quotes) and a numeric expression result (2 to the power 100) to the output stream. Don’t worry about the syntax of this code yet—for this chapter, we’re interested only 28 | Chapter 2: How Python Runs Programs
- 81. in getting it to run. I’ll explain the print statement, and why you can raise 2 to the power 100 in Python without overflowing, in the next parts of this book. You can create such a file of statements with any text editor you like. By convention, Python program files are given names that end in .py; technically, this naming scheme is required only for files that are “imported”—a term clarified in the next chapter—but most Python files have .py names for consistency. After you’ve typed these statements into a text file, you must tell Python to execute the file—which simply means to run all the statements in the file from top to bottom, one after another. As you’ll see in the next chapter, you can launch Python program files by shell command lines, by clicking their icons, from within IDEs, and with other standard techniques. If all goes well, when you execute the file, you’ll see the results of the two print statements show up somewhere on your computer—by default, usually in the same window you were in when you ran the program: Figure 2-1. When installed on Windows 7 and earlier, this is how Python shows up in your Start button menu. This can vary across releases, but IDLE starts a development GUI, and Python starts a simple interactive session. Also here are the standard manuals and the PyDoc documentation engine (Module Docs). See Chapter 3 and Appendix A for pointers on Windows 8 and other platforms. Program Execution | 29
- 82. hello world 1267650600228229401496703205376 For example, here’s what happened when I ran this script from a Command Prompt window’s command line on a Windows laptop, to make sure it didn’t have any silly typos: C:code> python script0.py hello world 1267650600228229401496703205376 See Chapter 3 for the full story on this process, especially if you’re new to programming; we’ll get into all the gory details of writing and launching programs there. For our purposes here, we’ve just run a Python script that prints a string and a number. We probably won’t win any programming awards with this code, but it’s enough to capture the basics of program execution. Python’s View The brief description in the prior section is fairly standard for scripting languages, and it’s usually all that most Python programmers need to know. You type code into text files, and you run those files through the interpreter. Under the hood, though, a bit more happens when you tell Python to “go.” Although knowledge of Python internals is not strictly required for Python programming, a basic understanding of the runtime structure of Python can help you grasp the bigger picture of program execution. When you instruct Python to run your script, there are a few steps that Python carries out before your code actually starts crunching away. Specifically, it’s first compiled to something called “byte code” and then routed to something called a “virtual machine.” Byte code compilation Internally, and almost completely hidden from you, when you execute a program Python first compiles your source code (the statements in your file) into a format known as byte code. Compilation is simply a translation step, and byte code is a lower-level, platform-independent representation of your source code. Roughly, Python translates each of your source statements into a group of byte code instructions by decomposing them into individual steps. This byte code translation is performed to speed execution —byte code can be run much more quickly than the original source code statements in your text file. You’ll notice that the prior paragraph said that this is almost completely hidden from you. If the Python process has write access on your machine, it will store the byte code of your programs in files that end with a .pyc extension (“.pyc” means compiled “.py” source). Prior to Python 3.2, you will see these files show up on your computer after you’ve run a few programs alongside the corresponding source code files—that is, in the same directories. For instance, you’ll notice a script.pyc after importing a script.py. 30 | Chapter 2: How Python Runs Programs
- 83. In 3.2 and later, Python instead saves its .pyc byte code files in a subdirectory named __pycache__ located in the directory where your source files reside, and in files whose names identify the Python version that created them (e.g., script.cpython-33.pyc). The new __pycache__ subdirectory helps to avoid clutter, and the new naming convention for byte code files prevents different Python versions installed on the same computer from overwriting each other’s saved byte code. We’ll study these byte code file models in more detail in Chapter 22, though they are automatic and irrelevant to most Python programs, and are free to vary among the alternative Python implementations described ahead. In both models, Python saves byte code like this as a startup speed optimization. The next time you run your program, Python will load the.pyc files and skip the compilation step, as long as you haven’t changed your source code since the byte code was last saved, and aren’t running with a different Python than the one that created the byte code. It works like this: • Source changes: Python automatically checks the last-modified timestamps of source and byte code files to know when it must recompile—if you edit and resave your source code, byte code is automatically re-created the next time your program is run. • Python versions: Imports also check to see if the file must be recompiled because it was created by a different Python version, using either a “magic” version number in the byte code file itself in 3.2 and earlier, or the information present in byte code filenames in 3.2 and later. The result is that both source code changes and differing Python version numbers will trigger a new byte code file. If Python cannot write the byte code files to your machine, your program still works—the byte code is generated in memory and simply discarded on program exit. However, because .pyc files speed startup time, you’ll want to make sure they are written for larger programs. Byte code files are also one way to ship Python programs—Python is happy to run a program if all it can find are .pyc files, even if the original .py source files are absent. (See “Frozen Binaries” on page 39 for another shipping option.) Finally, keep in mind that byte code is saved in files only for files that are imported, not for the top-level files of a program that are only run as scripts (strictly speaking, it’s an import optimization). We’ll explore import basics in Chapter 3, and take a deeper look at imports in Part V. Moreover, a given file is only imported (and possibly compiled) once per program run, and byte code is also never saved for code typed at the interactive prompt—a programming mode we’ll learn about in Chapter 3. The Python Virtual Machine (PVM) Once your program has been compiled to byte code (or the byte code has been loaded from existing .pyc files), it is shipped off for execution to something generally known as the Python Virtual Machine (PVM, for the more acronym-inclined among you). The Program Execution | 31
- 84. PVM sounds more impressive than it is; really, it’s not a separate program, and it need not be installed by itself. In fact, the PVM is just a big code loop that iterates through your byte code instructions, one by one, to carry out their operations. The PVM is the runtime engine of Python; it’s always present as part of the Python system, and it’s the component that truly runs your scripts. Technically, it’s just the last step of what is called the “Python interpreter.” Figure 2-2 illustrates the runtime structure described here. Keep in mind that all of this complexity is deliberately hidden from Python programmers. Byte code compilation is automatic, and the PVM is just part of the Python system that you have installed on your machine. Again, programmers simply code and run files of statements, and Python handles the logistics of running them. Performance implications Readers with a background in fully compiled languages such as C and C++ might notice a few differences in the Python model. For one thing, there is usually no build or “make” step in Python work: code runs immediately after it is written. For another, Python byte code is not binary machine code (e.g., instructions for an Intel or ARM chip). Byte code is a Python-specific representation. This is why some Python code may not run as fast as C or C++ code, as described in Chapter 1—the PVM loop, not the CPU chip, still must interpret the byte code, and byte code instructions require more work than CPU instructions. On the other hand, unlike in classic interpreters, there is still an internal compile step—Python does not need to reanalyze and reparse each source statement’s text repeatedly. The net effect is that pure Python code runs at speeds somewhere between those of a traditional compiled language and a traditional interpreted language. See Chapter 1 for more on Python performance tradeoffs. Development implications Another ramification of Python’s execution model is that there is really no distinction between the development and execution environments. That is, the systems that com- pile and execute your source code are really one and the same. This similarity may have Figure 2-2. Python’s traditional runtime execution model: source code you type is translated to byte code, which is then run by the Python Virtual Machine. Your code is automatically compiled, but then it is interpreted. 32 | Chapter 2: How Python Runs Programs
- 85. a bit more significance to readers with a background in traditional compiled languages, but in Python, the compiler is always present at runtime and is part of the system that runs programs. This makes for a much more rapid development cycle. There is no need to precompile and link before execution may begin; simply type and run the code. This also adds a much more dynamic flavor to the language—it is possible, and often very convenient, for Python programs to construct and execute other Python programs at runtime. The eval and exec built-ins, for instance, accept and run strings containing Python program code. This structure is also why Python lends itself to product customization—because Python code can be changed on the fly, users can modify the Python parts of a system onsite without needing to have or compile the entire system’s code. At a more fundamental level, keep in mind that all we really have in Python is runtime— there is no initial compile-time phase at all, and everything happens as the program is running. This even includes operations such as the creation of functions and classes and the linkage of modules. Such events occur before execution in more static lan- guages, but happen as programs execute in Python. As we’ll see, this makes for a much more dynamic programming experience than that to which some readers may be ac- customed. Execution Model Variations Now that we’ve studied the internal execution flow described in the prior section, I should note that it reflects the standard implementation of Python today but is not really a requirement of the Python language itself. Because of that, the execution model is prone to changing with time. In fact, there are already a few systems that modify the picture in Figure 2-2 somewhat. Before moving on, let’s briefly explore the most prom- inent of these variations. Python Implementation Alternatives Strictly speaking, as this book edition is being written, there are at least five imple- mentations of the Python language—CPython, Jython, IronPython, Stackless, and PyPy. Although there is much cross-fertilization of ideas and work between these Py- thons, each is a separately installed software system, with its own developers and user base. Other potential candidates here include the Cython and Shed Skin systems, but they are discussed later as optimization tools because they do not implement the stan- dard Python language (the former is a Python/C mix, and the latter is implicitly stati- cally typed). In brief, CPython is the standard implementation, and the system that most readers will wish to use (if you’re not sure, this probably includes you). This is also the version used in this book, though the core Python language presented here is almost entirely the same in the alternatives. All the other Python implementations have specific pur- Execution Model Variations | 33
- 86. poses and roles, though they can often serve in most of CPython’s capacities too. All implement the same Python language but execute programs in different ways. For example, PyPy is a drop-in replacement for CPython, which can run most programs much quicker. Similarly, Jython and IronPython are completely independent imple- mentations of Python that compile Python source for different runtime architectures, to provide direct access to Java and .NET components. It is also possible to access Java and .NET software from standard CPython programs—JPype and Python for .NET systems, for instance, allow standard CPython code to call out to Java and .NET com- ponents. Jython and IronPython offer more complete solutions, by providing full im- plementations of the Python language. Here’s a quick rundown on the most prominent Python implementations available today. CPython: The standard The original, and standard, implementation of Python is usually called CPython when you want to contrast it with the other options (and just plain “Python” otherwise). This name comes from the fact that it is coded in portable ANSI C language code. This is the Python that you fetch from http://www.python.org, get with the ActivePython and Enthought distributions, and have automatically on most Linux and Mac OS X ma- chines. If you’ve found a preinstalled version of Python on your machine, it’s probably CPython, unless your company or organization is using Python in more specialized ways. Unless you want to script Java or .NET applications with Python or find the benefits of Stackless or PyPy compelling, you probably want to use the standard CPython sys- tem. Because it is the reference implementation of the language, it tends to run the fastest, be the most complete, and be more up-to-date and robust than the alternative systems. Figure 2-2 reflects CPython’s runtime architecture. Jython: Python for Java The Jython system (originally known as JPython) is an alternative implementation of the Python language, targeted for integration with the Java programming language. Jython consists of Java classes that compile Python source code to Java byte code and then route the resulting byte code to the Java Virtual Machine (JVM). Programmers still code Python statements in .py text files as usual; the Jython system essentially just replaces the rightmost two bubbles in Figure 2-2 with Java-based equivalents. Jython’s goal is to allow Python code to script Java applications, much as CPython allows Python to script C and C++ components. Its integration with Java is remarkably seamless. Because Python code is translated to Java byte code, it looks and feels like a true Java program at runtime. Jython scripts can serve as web applets and servlets, build Java-based GUIs, and so on. Moreover, Jython includes integration support that allows Python code to import and use Java classes as though they were coded in Python, and 34 | Chapter 2: How Python Runs Programs
- 87. Java code to run Python code as an embedded language. Because Jython is slower and less robust than CPython, though, it is usually seen as a tool of interest primarily to Java developers looking for a scripting language to serve as a frontend to Java code. See Jython’s website http://jython.org for more details. IronPython: Python for .NET A third implementation of Python, and newer than both CPython and Jython, IronPy- thon is designed to allow Python programs to integrate with applications coded to work with Microsoft’s .NET Framework for Windows, as well as the Mono open source equivalent for Linux. .NET and its C# programming language runtime system are de- signed to be a language-neutral object communication layer, in the spirit of Microsoft’s earlier COM model. IronPython allows Python programs to act as both client and server components, gain accessibility both to and from other .NET languages, and lever- age .NET technologies such as the Silverlight framework from their Python code. By implementation, IronPython is very much like Jython (and, in fact, was developed by the same creator)—it replaces the last two bubbles in Figure 2-2 with equivalents for execution in the .NET environment. Also like Jython, IronPython has a special focus —it is primarily of interest to developers integrating Python with .NET components. Formerly developed by Microsoft and now an open source project, IronPython might also be able to take advantage of some important optimization tools for better perfor- mance. For more details, consult http://ironpython.net and other resources to be had with a web search. Stackless: Python for concurrency StillotherschemesforrunningPythonprogramshavemorefocusedgoals.Forexample, the Stackless Python system is an enhanced version and reimplementation of the stan- dard CPython language oriented toward concurrency. Because it does not save state on the C language call stack, Stackless Python can make Python easier to port to small stack architectures, provides efficient multiprocessing options, and fosters novel pro- gramming structures such as coroutines. Among other things, the microthreads that Stackless adds to Python are an efficient and lightweight alternative to Python’s standard multitasking tools such as threads and processes, and promise better program structure, more readable code, and increased programmer productivity. CCP Games, the creator of EVE Online, is a well-known Stackless Python user, and a compelling Python user success story in general. Try http: //stackless.com for more information. PyPy: Python for speed The PyPy system is another standard CPython reimplementation, focused on perfor- mance. It provides a fast Python implementation with a JIT (just-in-time) compiler, provides tools for a “sandbox” model that can run untrusted code in a secure environ- Execution Model Variations | 35
- 88. ment, and by default includes support for the prior section’s Stackless Python systems and its microthreads to support massive concurrency. PyPy is the successor to the original Psyco JIT, described ahead, and subsumes it with a complete Python implementation built for speed. A JIT is really just an extension to the PVM—the rightmost bubble in Figure 2-2—that translates portions of your byte code all the way to binary machine code for faster execution. It does this as your pro- gram is running, not in a prerun compile step, and is able to created type-specific ma- chine code for the dynamic Python language by keeping track of the data types of the objects your program processes. By replacing portions of your byte code this way, your program runs faster and faster as it is executing. In addition, some Python programs may also take up less memory under PyPy. At this writing, PyPy supports Python 2.7 code (not yet 3.X) and runs on Intel x86 (IA-32) and x86_64 platforms (including Windows, Linux, and recent Macs), with ARM and PPC support under development. It runs most CPython code, though C extension modules must generally be recompiled, and PyPy has some minor but subtle language differences, including garbage collection semantics that obviate some com- mon coding patterns. For instance, its non-reference-count scheme means that tem- porary files may not close and flush output buffers immediately, and may require man- ual close calls in some cases. In return, your code may run much quicker. PyPy currently claims a 5.7X speedup over CPython across a range of benchmark programs (per http://speed.pypy.org/). In some cases, its ability to take advantage of dynamic optimization opportunities can make Python code as quick as C code, and occasionally faster. This is especially true for heavily algorithmic or numeric programs, which might otherwise be recoded in C. For instance, in one simple benchmark we’ll see in Chapter 21, PyPy today clocks in at 10X faster than CPython 2.7, and 100X faster than CPython 3.X. Though other benchmarks will vary, such speedups may be a compelling advantage in many domains, perhaps even more so than leading-edge language features. Just as important, memory space is also optimized in PyPy—in the case of one posted benchmark, requiring 247 MB and completing in 10.3 seconds, compared to CPython’s 684 MB and 89 seconds. PyPy’s tool chain is also general enough to support additional languages, including Pyrolog, a Prolog interpreter written in Python using the PyPy translator. Search for PyPy’s website for more. PyPy currently lives at http://pypy.org, though the usual web search may also prove fruitful over time. For an overview of its current performance, also see http://www.pypy.org/performance.html. 36 | Chapter 2: How Python Runs Programs
- 89. JustafterIwrotethis,PyPy2.0wasreleasedinbetaform,addingsupport for the ARM processor, and still a Python 2.X-only implementation. Per its 2.0 beta release notes: “PyPy is a very compliant Python interpreter, almost a drop-in replace- ment for CPython 2.7.3. It’s fast due to its integrated tracing JIT com- piler. This release supports x86 machines running Linux 32/64, Mac OS X 64 or Windows 32. It also supports ARM machines running Linux.” The claims seem accurate. Using the timing tools we’ll study in Chap- ter 21, PyPy is often an order of magnitude (factor of 10) faster than CPython 2.X and 3.X on tests I’ve run, and sometimes even better. This is despite the fact that PyPy is a 32-bit build on my Windows test ma- chine, while CPython is a faster 64-bit compile. Naturally the only benchmark that truly matters is your own code, and there are cases where CPython wins the race; PyPy’s file iterators, for instance, may clock in slower today. Still, given PyPy’s focus on perfor- mance over language mutation, and especially its support for the nu- meric domain, many today see PyPy as an important path for Python. If you write CPU-intensive code, PyPy deserves your attention. Execution Optimization Tools CPython and most of the alternatives of the prior section all implement the Python language in similar ways: by compiling source code to byte code and executing the byte code on an appropriate virtual machine. Some systems, such as the Cython hybrid, the Shed Skin C++ translator, and the just-in-time compilers in PyPy and Psyco instead attempt to optimize the basic execution model. These systems are not required knowl- edge at this point in your Python career, but a quick look at their place in the execution model might help demystify the model in general. Cython: A Python/C hybrid The Cython system (based on work done by the Pyrex project) is a hybrid language that combines Python code with the ability to call C functions and use C type declarations for variables, parameters, and class attributes. Cython code can be compiled to C code that uses the Python/C API, which may then be compiled completely. Though not completely compatible with standard Python, Cython can be useful both for wrapping external C libraries and for coding efficient C extensions for Python. See http://cython .org for current status and details. Shed Skin: A Python-to-C++ translator Shed Skin is an emerging system that takes a different approach to Python program execution—it attempts to translate Python source code to C++ code, which your com- puter’s C++ compiler then compiles to machine code. As such, it represents a platform- neutral approach to running Python code. Execution Model Variations | 37
- 90. Shed Skin is still being actively developed as I write these words. It currently supports Python 2.4 to 2.6 code, and it limits Python programs to an implicit statically typed constraint that is typical of most programs but is technically not normal Python, so we won’t go into further detail here. Initial results, though, show that it has the potential to outperform both standard Python and Psyco-like extensions in terms of execution speed. Search the Web for details on the project’s current status. Psyco: The original just-in-time compiler The Psyco system is not another Python implementation, but rather a component that extends the byte code execution model to make programs run faster. Today, Psyco is something of an ex-project: it is still available for separate download, but has fallen out of date with Python’s evolution, and is no longer actively maintained. Instead, its ideas have been incorporated into the more complete PyPy system described earlier. Still, the ongoing importance of the ideas Psyco explored makes them worth a quick look. In terms of Figure 2-2, Psyco is an enhancement to the PVM that collects and uses type information while the program runs to translate portions of the program’s byte code all the way down to true binary machine code for faster execution. Psyco accomplishes this translation without requiring changes to the code or a separate compilation step during development. Roughly, while your program runs, Psyco collects information about the kinds of ob- jects being passed around; that information can be used to generate highly efficient machine code tailored for those object types. Once generated, the machine code then replaces the corresponding part of the original byte code to speed your program’s over- all execution. The result is that with Psyco, your program becomes quicker over time as it runs. In ideal cases, some Python code may become as fast as compiled C code under Psyco. Because this translation from byte code happens at program runtime, Psyco is known as a just-in-time compiler. Psyco is different from the JIT compilers some readers may have seen for the Java language, though. Really, Psyco is a specializing JIT compiler— it generates machine code tailored to the data types that your program actually uses. For example, if a part of your program uses different data types at different times, Psyco may generate a different version of machine code to support each different type com- bination. Psyco was shown to speed some Python code dramatically. According to its web page, Psyco provides “2X to 100X speed-ups, typically 4X, with an unmodified Python in- terpreter and unmodified source code, just a dynamically loadable C extension mod- ule.” Of equal significance, the largest speedups are realized for algorithmic code writ- ten in pure Python—exactly the sort of code you might normally migrate to C to op- timize. For more on Psyco, search the Web or see its successor—the PyPy project de- scribed previously. 38 | Chapter 2: How Python Runs Programs
- 91. Frozen Binaries Sometimes when people ask for a “real” Python compiler, what they’re really seeking is simply a way to generate standalone binary executables from their Python programs. This is more a packaging and shipping idea than an execution-flow concept, but it’s somewhat related. With the help of third-party tools that you can fetch off the Web, it is possible to turn your Python programs into true executables, known as frozen bi- naries in the Python world. These programs can be run without requiring a Python installation. Frozen binaries bundle together the byte code of your program files, along with the PVM (interpreter) and any Python support files your program needs, into a single package. There are some variations on this theme, but the end result can be a single binary executable program (e.g., an .exe file on Windows) that can easily be shipped to customers. In Figure 2-2, it is as though the two rightmost bubbles—byte code and PVM—are merged into a single component: a frozen binary file. Today, a variety of systems are capable of generating frozen binaries, which vary in platforms and features: py2exe for Windows only, but with broad Windows support; PyInstaller, which is similar to py2exe but also works on Linux and Mac OS X and is capable of generating self-installing binaries; py2app for creating Mac OS X applica- tions; freeze, the original; and cx_freeze, which offers both Python 3.X and cross-plat- form support. You may have to fetch these tools separately from Python itself, but they are freely available. These tools are also constantly evolving, so consult http://www.python.org or your fa- vorite web search engine for more details and status. To give you an idea of the scope of these systems, py2exe can freeze standalone programs that use the tkinter, PMW, wxPython, and PyGTK GUI libraries; programs that use the pygame game program- ming toolkit; win32com client programs; and more. Frozen binaries are not the same as the output of a true compiler—they run byte code through a virtual machine. Hence, apart from a possible startup improvement, frozen binaries run at the same speed as the original source files. Frozen binaries are also not generally small (they contain a PVM), but by current standards they are not unusually large either. Because Python is embedded in the frozen binary, though, it does not have to be installed on the receiving end to run your program. Moreover, because your code is embedded in the frozen binary, it is more effectively hidden from recipients. This single file-packaging scheme is especially appealing to developers of commercial software. For instance, a Python-coded user interface program based on the tkinter toolkit can be frozen into an executable file and shipped as a self-contained program on a CD or on the Web. End users do not need to install (or even have to know about) Python to run the shipped program. Execution Model Variations | 39
- 92. Future Possibilities? Finally, note that the runtime execution model sketched here is really an artifact of the current implementation of Python, not of the language itself. For instance, it’s not impossible that a full, traditional compiler for translating Python source code to ma- chine code may appear during the shelf life of this book (although the fact that one has not in over two decades makes this seem unlikely!). New byte code formats and implementation variants may also be adopted in the future. For instance: • The ongoing Parrot project aims to provide a common byte code format, virtual machine, and optimization techniques for a variety of programming languages, including Python. Python’s own PVM runs Python code more efficiently than Par- rot (as famously demonstrated by a pie challenge at a software conference—search the Web for details), but it’s unclear how Parrot will evolve in relation to Python specifically. See http://parrot.org or the Web at large for details. • The former Unladen Swallow project—an open source project developed by Goo- gle engineers—sought to make standard Python faster by a factor of at least 5, and fast enough to replace the C language in many contexts. This was an optimization branch of CPython (specifically Python 2.6), intended to be compatible yet faster by virtue of adding a JIT to standard Python. As I write this in 2012, this project seems to have drawn to a close (per its withdrawn Python PEP, it was “going the way of the Norwegian Blue”). Still, its lessons gained may be leveraged in other forms; search the Web for breaking developments. Although future implementation schemes may alter the runtime structure of Python somewhat, it seems likely that the byte code compiler will still be the standard for some time to come. The portability and runtime flexibility of byte code are important features of many Python systems. Moreover, adding type constraint declarations to support static compilation would likely break much of the flexibility, conciseness, simplicity, and overall spirit of Python coding. Due to Python’s highly dynamic nature, any future implementation will likely retain many artifacts of the current PVM. Chapter Summary This chapter introduced the execution model of Python—how Python runs your pro- grams—and explored some common variations on that model: just-in-time compilers and the like. Although you don’t really need to come to grips with Python internals to write Python scripts, a passing acquaintance with this chapter’s topics will help you truly understand how your programs run once you start coding them. In the next chapter, you’ll start actually running some code of your own. First, though, here’s the usual chapter quiz. 40 | Chapter 2: How Python Runs Programs
- 93. Test Your Knowledge: Quiz 1. What is the Python interpreter? 2. What is source code? 3. What is byte code? 4. What is the PVM? 5. Name two or more variations on Python’s standard execution model. 6. How are CPython, Jython, and IronPython different? 7. What are Stackless and PyPy? Test Your Knowledge: Answers 1. The Python interpreter is a program that runs the Python programs you write. 2. Source code is the statements you write for your program—it consists of text in text files that normally end with a .py extension. 3. Byte code is the lower-level form of your program after Python compiles it. Python automatically stores byte code in files with a .pyc extension. 4. The PVM is the Python Virtual Machine—the runtime engine of Python that in- terprets your compiled byte code. 5. Psyco, Shed Skin, and frozen binaries are all variations on the execution model. In addition,thealternativeimplementationsofPythonnamedinthenexttwoanswers modify the model in some fashion as well—by replacing byte code and VMs, or by adding tools and JITs. 6. CPython is the standard implementation of the language. Jython and IronPython implement Python programs for use in Java and .NET environments, respectively; they are alternative compilers for Python. 7. Stackless is an enhanced version of Python aimed at concurrency, and PyPy is a reimplementation of Python targeted at speed. PyPy is also the successor to Psyco, and incorporates the JIT concepts that Psyco pioneered. Test Your Knowledge: Answers | 41
- 95. CHAPTER 3 How You Run Programs OK, it’s time to start running some code. Now that you have a handle on the program execution model, you’re finally ready to start some real Python programming. At this point, I’ll assume that you have Python installed on your computer; if you don’t, see the start of the prior chapter and Appendix A for installation and configuration hints on various platforms. Our goal here is to learn how to run Python program code. There are multiple ways to tell Python to execute the code you type. This chapter discusses all the program launching techniques in common use today. Along the way, you’ll learn how to both type code interactively, and how to save it in files to be run as often as you like in a variety of ways: with system command lines, icon clicks, module imports, exec calls, menu options in the IDLE GUI, and more. As for the previous chapter, if you have prior programming experience and are anxious to start digging into Python itself, you may want to skim this chapter and move on to Chapter 4. But don’t skip this chapter’s early coverage of preliminaries and conven- tions, its overview of debugging techniques, or its first look at module imports—a topic essential to understanding Python’s program architecture, which we won’t revisit until a later part. I also encourage you to see the sections on IDLE and other IDEs, so you’ll know what tools are available when you start developing more sophisticated Python programs. The Interactive Prompt This section gets us started with interactive coding basics. Because it’s our first look at running code, we also cover some preliminaries here, such as setting up a working directory and the system path, so be sure to read this section first if you’re relatively new to programming. This section also explains some conventions used throughout the book, so most readers should probably take at least a quick look here. 43
- 96. Starting an Interactive Session Perhaps the simplest way to run Python programs is to type them at Python’s interactive command line, sometimes called the interactive prompt. There are a variety of ways to start this command line: in an IDE, from a system console, and so on. Assuming the interpreter is installed as an executable program on your system, the most platform- neutral way to start an interactive interpreter session is usually just to type python at your operating system’s prompt, without any arguments. For example: % python Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ... Type "help", "copyright", "credits" or "license" for more information. >>> ^Z Typing the word “python” at your system shell prompt like this begins an interactive Python session; the “%” character at the start of this listing stands for a generic system prompt in this book—it’s not input that you type yourself. On Windows, a Ctrl-Z gets you out of this session; on Unix, try Ctrl-D instead. The notion of a system shell prompt is generic, but exactly how you access it varies by platform: • On Windows, you can type python in a DOS console window—a program named cmd.exe and usually known as Command Prompt. For more details on starting this program, see this chapter’s sidebar “Where Is Command Prompt on Win- dows?” on page 45. • On Mac OS X, you can start a Python interactive interpreter by double-clicking on Applications→Utilities→Terminal, and then typing python in the window that opens up. • On Linux (and other Unixes), you might type this command in a shell or terminal window (for instance, in an xterm or console running a shell such as ksh or csh). • Other systems may use similar or platform-specific devices. On handheld devices, for example, you might click the Python icon in the home or application window to launch an interactive session. On most platforms, you can start the interactive prompt in additional ways that don’t require typing a command, but they vary per platform even more widely: • On Windows 7 and earlier, besides typing python in a shell window, you can also begin similar interactive sessions by starting the IDLE GUI (discussed later), or by selecting the “Python (command line)” menu option from the Start button menu for Python, as shown in Figure 2-1 in Chapter 2. Both spawn a Python interactive prompt with the same functionality obtained with a “python” command. • On Windows 8, you don’t have a Start button (at least as I write this), but there are other ways to get to the tools described in the prior bullet, including tiles, Search, File Explorer, and the “All apps” interface on the Start screen. See Appendix A for more pointers on this platform. 44 | Chapter 3: How You Run Programs
- 97. • Other platforms have similar ways to start a Python interactive session without typing commands, but they’re too specific to get into here; see your system’s doc- umentation for details. Anytime you see the >>> prompt, you’re in an interactive Python interpreter session— you can type any Python statement or expression here and run it immediately. We will in a moment, but first we need to get a few startup details sorted out to make sure all readers are set to go. Where Is Command Prompt on Windows? So how do you start the command-line interface on Windows? Some Windows readers already know, but Unix developers and beginners may not; it’s not as prominent as terminal or console windows on Unix systems. Here are some pointers on finding your Command Prompt, which vary slightly per Windows version. On Windows 7 and earlier, this is usually found in the Accessories section of the Start→All Programs menu, or you can run it by typing cmd in the Start→Run... dialog box or the Start menu’s search entry field. You can drag out a desktop shortcut to get to it quicker if desired. On Windows 8, you can access Command Prompt in the menu opened by right-clicking on the preview in the screen’s lower-left corner; in the Windows System section of the “All apps” display reached by right-clicking your Start screen; or by typing cmd or command prompt in the input field of the Search charm pulled down from the screen’s upper-right corner. There are probably additional routes, and touch screens offer sim- ilar access. And if you want to forget all that, pin it to your desktop taskbar for easy access next time around. These procedures are prone to vary over time, and possibly even per computer and user. I’m trying to avoid making this a book on Windows, though, so I’ll cut this topic short here. When in doubt, try the system Help interface (whose usage may differ as much as the tools it provides help for!). A note to any Unix users reading this sidebar who may be starting to feel like a fish out of water: you may also be interested in the Cygwin system, which brings a full Unix command prompt to Windows. See Appendix A for more pointers. The System Path When we typed python in the last section to start an interactive session, we relied on the fact that the system located the Python program for us on its program search path. Depending on your Python version and platform, if you have not set your system’s PATH environmentvariabletoincludePython’sinstall directory,youmayneedtoreplace the word “python” with the full path to the Python executable on your machine. On Unix, Linux, and similar, something like /usr/local/bin/python or /usr/bin/python3 will often suffice. On Windows, try typing C:Python33python (for version 3.3): The Interactive Prompt | 45
- 98. c:code> c:python33python Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ... Type "help", "copyright", "credits" or "license" for more information. >>> ^Z Alternatively, you can run a “cd” change-directory command to go to Python’s install directory before typing python—try the cd c:python33 command on Windows, for example: c:code> cd c:python33 c:Python33> python Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ... Type "help", "copyright", "credits" or "license" for more information. >>> ^Z But you’ll probably want to set your PATH eventually, so a simple “python” suffices. If you don’t know what PATH is or how to set it, see Appendix A—it covers environment variables like this whose usage varies per platform, as well as Python command-line arguments we won’t be using much in this book. The short story for Windows users: see the Advanced settings in the System entry of your Control Panel. If you’re using Python 3.3 and later, this is now automatic on Windows, as the next section explains. New Windows Options in 3.3: PATH, Launcher The foregoing section and much of this chapter at large describe the generic state of play for all 2.X and 3.X Pythons prior to version 3.3. Starting with Python 3.3, the Windows installer has an option to automatically add Python 3.3’s directory to your system PATH, if enabled in the installer’s windows. If you use this option, you won’t need to type a directory path or issue a “cd” to run python commands as in the prior section. Be sure to select this option during the install if you want it, as it’s currently disabled by default. More dramatically, Python 3.3 for Windows ships with and automatically installs the new Windows launcher—a system that comes with new executable programs, py with a console and pyw without, that are placed in directories on your system path, and so may be run out of the box without any PATH configurations, change-directory com- mands, or directory path prefixes: c:code> py Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit ... Type "help", "copyright", "credits" or "license" for more information. >>> ^Z c:code> py −2 Python 2.7.3 (default, Apr 10 2012, 23:24:47) [MSC v.1500 64 bit (AMD64)] ... Type "help", "copyright", "credits" or "license" for more information. >>> ^Z c:code> py −3.1 Python 3.1.4 (default, Jun 12 2011, 14:16:16) [MSC v.1500 64 bit (AMD64)] ... 46 | Chapter 3: How You Run Programs
- 99. Type "help", "copyright", "credits" or "license" for more information. >>> ^Z As shown in the last two commands here, these executables also accept Python version numbers on the command line (and in Unix-style #! lines at the top of scripts, as dis- cussed later), and are associated to open Python files when clicked just like the original python executable—which is still available and works as before, but is somewhat su- perseded by the launcher’s new programs. The launcher is a standard part of Python 3.3, and is available standalone for use with other versions. We’ll see more on this new launcher in this and later chapters, including abrieflookatits#! linesupporthere.However,becauseitisofinterestonlytoWindows users, and even for this group is present only in 3.3 or where installed separately, I’ve collected almost all of the details about the launcher in Appendix B. If you’ll be working on Windows under Python 3.3 or later, I suggest taking a brief detour to that appendix now, as it provides an alternative, and in some ways better, way to run Python command lines and scripts. At a base level, launcher users can type py instead of python in most of the system commands shown in this book, and may avoid some configuration steps. Especially on computers with multiple Python ver- sions, though, the new launcher gives you more explicit control over which Python runs your code. Where to Run: Code Directories Now that I’ve started showing you how to run code, I want to say a few words up front about where to run code. To keep things simple, in this chapter and book at large I’m going to be running code from a working directory (a.k.a. folder) I’ve created on my Windows computer called C:code—a subdirectory at the top of my main drive. That’s where I’ll start most interactive sessions, and where I’ll be both saving and running most script files. This also means the files that examples will create will mostly show up in this directory. If you’ll be working along, you should probably do something similar before we get started. Here are some pointers if you need help getting set up with a working directory on your computer: • On Windows, you can make your working code directory in File Explorer or a Command Prompt window. In File Explorer, look for New Folder, see the File menu, or try a right-click. In Command Prompt, type and run a mkdir command, usually after you cd to your desired parent directory (e.g., cd c: and mkdir code). Your working directory can be located wherever you like and called whatever you wish, and doesn’t have to be C:code (I chose this name because it’s short in prompts). But running out of one directory will help you keep track of your work and simplify some tasks. For more Windows hints, see this chapter’s sidebar on Command Prompt, as well as Appendix A. The Interactive Prompt | 47
- 100. • On Unix-based systems (including Mac OS X and Linux), your working directory might be in /usr/home and be created by a mkdir command in a shell window or file explorer GUI specific to your platform, but the same concepts apply. The Cyg- win Unix-like system for Windows is similar too, though your directory names may vary (/home and /cygdrive/c are candidates). You can store your code in Python’s install directory too (e.g., C:Python33 on Win- dows) to simplify some command lines before setting PATH, but you probably shouldn’t —this is for Python itself, and your files may not survive a move or uninstall. Once you’ve made your working directory, always start there to work along with the examples in this book. The prompts in this book that show the directory that I’m running code in will reflect my Windows laptop’s working directory; when you see C: code> or %, think the location and name of your own directory. What Not to Type: Prompts and Comments Speaking of prompts, this book sometimes shows system prompts as a generic %, and sometimes in full C:code> Windows form. The former is meant to be platform agnostic (and derives from earlier editions’ use of Linux), and the latter is used in Windows- specific contexts. I also add a space after system prompts just for readability in this book. When used, the % character at the start of a system command line stands for the system’s prompt, whatever that may be on your machine. For instance, on my machine % stands for C:code> in Windows Command Prompt, and just $ in my Cygwn install. To beginners: don’t type the % character (or the C:code system prompt it sometimes stands for) you see in this book’s interaction listings yourself—this is text the system prints. Type just the text after these system prompts. Similarly, do not type the >>> and ... characters shown at the start of lines in interpreter interaction listings—these are prompts that Python displays automatically as visual guides for interactive code entry. Type just the text after these Python prompts. For instance, the ... prompt is used for continuation lines in some shells, but doesn’t appear in IDLE, and shows up in some but not all of this book’s listings; don’t type it yourself if it’s absent in your interface. To help you remember this, user inputs are shown in bold in this book, and prompts are not. In some systems these prompts may differ (for instance, the PyPy performance- focused implementation described in Chapter 2 uses four-character >>>> and ....), but the same rules apply. Also keep in mind that commands typed after these system and Python prompts are meant to be run immediately, and are not generally to be saved in the source files we will be creating; we’ll see why this distinction matters ahead. In the same vein, you normally don’t need to type text that starts with a # character in listings in this book—as you’ll learn, these are comments, not executable code. Except when # is used to introduce a directive at the top of a script for Unix or the Python 3.3 48 | Chapter 3: How You Run Programs
- 101. Windows launcher, you can safely ignore the text that follows it (more on Unix and the launcher later in this chapter and in Appendix B). If you’re working along, interactive listings will drop most “...” contin- uation prompts as of Chapter 17 to aid cut-and-paste of larger code such as functions and classes from ebooks or other; until then, paste or type one line at a time and omit the prompts. At least initially, it’s important to type code manually, to get a feel for syntax details and errors. Some examples will be listed either by themselves or in named files available in the book’s examples package (per the preface), and we’ll switch be- tween listing formats often; when in doubt, if you see “>>>”, it means the code is being typed interactively. Running Code Interactively With those preliminaries out of the way, let’s move on to typing some actual code. However it’s started, the Python interactive session begins by printing two lines of informational text giving the Python version number and a few hints shown earlier (which I’ll omit from most of this book’s examples to save space), then prompts for input with >>> when it’s waiting for you to type a new Python statement or expression. When working interactively, the results of your code are displayed below the >>> input lines after you press the Enter key. For instance, here are the results of two Python print statements (print is really a function call in Python 3.X, but not in 2.X, so the parentheses here are required in 3.X only): % python >>> print('Hello world!') Hello world! >>> print(2 ** 8) 256 There it is—we’ve just run some Python code (were you expecting the Spanish Inqui- sition?). Don’t worry about the details of the print statements shown here yet; we’ll start digging into syntax in the next chapter. In short, they print a Python string and an integer, as shown by the output lines that appear after each >>> input line (2 ** 8 means 2 raised to the power 8 in Python). When coding interactively like this, you can type as many Python commands as you like; each is run immediately after it’s entered. Moreover, because the interactive ses- sion automatically prints the results of expressions you type, you don’t usually need to say “print” explicitly at this prompt: >>> lumberjack = 'okay' >>> lumberjack 'okay' >>> 2 ** 8 256 The Interactive Prompt | 49
- 102. >>> ^Z # Use Ctrl-D (on Unix) or Ctrl-Z (on Windows) to exit % Here, the first line saves a value by assigning it to a variable (lumberjack), which is created by the assignment; and the last two lines typed are expressions (lumberjack and 2 ** 8), whose results are displayed automatically. Again, to exit an interactive session like this and return to your system shell prompt, type Ctrl-D on Unix-like machines, and Ctrl-Z on Windows. In the IDLE GUI discussed later, either type Ctrl-D or simply close the window. Notice the italicized note about this on the right side of this listing (staring with “#” here). I’ll use these throughout to add remarks about what is being illustrated, but you don’t need to type this text yourself. In fact, just like system and Python prompts, you shouldn’t type this when it’s on a system command line; the “#” part is taken as a comment by Python but may be an error at a system prompt. Now, we didn’t do much in this session’s code—just typed some Python print and assignment statements, along with a few expressions, which we’ll study in detail later. The main thing to notice is that the interpreter executes the code entered on each line immediately, when the Enter key is pressed. For example, when we typed the first print statement at the >>> prompt, the output (a Python string) was echoed back right away. There was no need to create a source code file, and no need to run the code through a compiler and linker first, as you’d normally do when using a language such as C or C++. As you’ll see in later chapters, you can also run multiline statements at the interactive prompt; such a statement runs imme- diately after you’ve entered all of its lines and pressed Enter twice to add a blank line. Why the Interactive Prompt? The interactive prompt runs code and echoes results as you go, but it doesn’t save your code in a file. Although this means you won’t do the bulk of your coding in interactive sessions, the interactive prompt turns out to be a great place to both experiment with the language and test program files on the fly. Experimenting Because code is executed immediately, the interactive prompt is a perfect place to ex- periment with the language and will be used often in this book to demonstrate smaller examples. In fact, this is the first rule of thumb to remember: if you’re ever in doubt about how a piece of Python code works, fire up the interactive command line and try it out to see what happens. For instance, suppose you’re reading a Python program’s code and you come across an expression like 'Spam!' * 8 whose meaning you don’t understand. At this point, you can spend 10 minutes wading through manuals, books, and the Web to try to figure out what the code does, or you can simply run it interactively: 50 | Chapter 3: How You Run Programs
- 103. % python >>> 'Spam!' * 8 # Learning by trying 'Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!' The immediate feedback you receive at the interactive prompt is often the quickest way to deduce what a piece of code does. Here, it’s clear that it does string repetition: in Python * means multiply for numbers, but repeat for strings—it’s like concatenating a string to itself repeatedly (more on strings in Chapter 4). Chances are good that you won’t break anything by experimenting this way—at least, not yet. To do real damage, like deleting files and running shell commands, you must really try, by importing modules explicitly (you also need to know more about Python’s system interfaces in general before you will become that dangerous!). Straight Python code is almost always safe to run. For instance, watch what happens when you make a mistake at the interactive prompt: >>> X # Making mistakes Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'X' is not defined In Python, using a variable before it has been assigned a value is always an error— otherwise, if names were filled in with defaults, some errors might go undetected. This means you must initial counters to zero before you can add to them, must initial lists before extending them, and so on; you don’t declare variables, but they must be as- signed before you can fetch their values. We’ll learn more about that later; the important point here is that you don’t crash Python or your computer when you make a mistake this way. Instead, you get a mean- ingful error message pointing out the mistake and the line of code that made it, and you can continue on in your session or script. In fact, once you get comfortable with Python, its error messages may often provide as much debugging support as you’ll need (you’ll learn more about debugging options in the sidebar “Debugging Python Code” on page 83). Testing Besides serving as a tool for experimenting while you’re learning the language, the interactive interpreter is also an ideal place to test code you’ve written in files. You can import your module files interactively and run tests on the tools they define by typing calls at the interactive prompt on the fly. For instance, the following tests a function in a precoded module that ships with Python in its standard library (it prints the name of the directory you’re currently working in, with a doubled-up backslash that stands for just one), but you can do the same once you start writing module files of your own: >>> import os >>> os.getcwd() # Testing on the fly 'c:code' The Interactive Prompt | 51
- 104. More generally, the interactive prompt is a place to test program components, regard- less of their source—you can import and test functions and classes in your Python files, type calls to linked-in C functions, exercise Java classes under Jython, and more. Partly because of its interactive nature, Python supports an experimental and exploratory programming style you’ll find convenient when getting started. Although Python pro- grammers also test with in-file code (and we’ll learn ways to make this simple later in the book), for many, the interactive prompt is still their first line of testing defense. Usage Notes: The Interactive Prompt Although the interactive prompt is simple to use, there are a few tips that beginners should keep in mind. I’m including lists of common mistakes like the following in this chapter for reference, but they might also spare you from a few headaches if you read them up front: • Type Python commands only. First of all, remember that you can only type Python code at Python’s >>> prompt, not system commands. There are ways to run system commands from within Python code (e.g., with os.system), but they are not as direct as simply typing the commands themselves. • print statements are required only in files. Because the interactive interpreter automatically prints the results of expressions, you do not need to type complete print statements interactively. This is a nice feature, but it tends to confuse users when they move on to writing code in files: within a code file, you must use print statements to see your output because expression results are not automati- cally echoed. Remember, you must say print in files, but it’s optional interactively. • Don’t indent at the interactive prompt (yet). When typing Python programs, either interactively or into a text file, be sure to start all your unnested statements in column 1 (that is, all the way to the left). If you don’t, Python may print a “SyntaxError” message, because blank space to the left of your code is taken to be indentation that groups nested statements. Until Chapter 10, all statements you write will be unnested, so this includes everything for now. Remember, a leading space generates an error message, so don’t start with a space or tab at the interactive prompt unless it’s nested code. • Watch out for prompt changes for compound statements. We won’t meet compound (multiline) statements until Chapter 4 and not in earnest until Chap- ter 10, but as a preview, you should know that when typing lines 2 and beyond of a compound statement interactively, the prompt may change. In the simple shell window interface, the interactive prompt changes to ... instead of >>> for lines 2 and beyond; in the IDLE GUI interface, lines after the first are instead automatically indented. You’ll see why this matters in Chapter 10. For now, if you happen to come across a... promptorablanklinewhenenteringyourcode,itprobablymeansthatyou’ve somehow confused interactive Python into thinking you’re typing a multiline 52 | Chapter 3: How You Run Programs
- 105. statement. Try hitting the Enter key or a Ctrl-C combination to get back to the main prompt. The >>> and ... prompt strings can also be changed (they are avail- able in the built-in module sys), but I’ll assume they have not been in the book’s example listings. • Terminate compound statements at the interactive prompt with a blank line. At the interactive prompt, inserting a blank line (by hitting the Enter key at the start of a line) is necessary to tell interactive Python that you’re done typing the multiline statement. That is, you must press Enter twice to make a compound statement run. By contrast, blank lines are not required in files and are simply ignored if present. If you don’t press Enter twice at the end of a compound state- mentwhenworkinginteractively,you’llappeartobestuckinalimbostate,because the interactive interpreter will do nothing at all—it’s waiting for you to press Enter again! • Theinteractivepromptrunsonestatementatatime.Attheinteractiveprompt, you must run one statement to completion before typing another. This is natural for simple statements, because pressing the Enter key runs the statement entered. For compound statements, though, remember that you must submit a blank line to terminate the statement and make it run before you can type the next statement. Entering multiline statements At the risk of repeating myself, I’ve received multiple emails from readers who’d gotten burned by the last two points, so they probably merit emphasis. I’ll introduce multiline (a.k.a. compound) statements in the next chapter, and we’ll explore their syntax more formally later in this book. Because their behavior differs slightly in files and at the interactive prompt, though, two cautions are in order here. First, be sure to terminate multiline compound statements like for loops and if tests at the interactive prompt with a blank line. In other words, you must press the Enter key twice, to terminate the whole multiline statement and then make it run. For example (pun not intended): >>> for x in 'spam': ... print(x) # Press Enter twice here to make this loop run ... You don’t need the blank line after compound statements in a script file, though; this is required only at the interactive prompt. In a file, blank lines are not required and are simply ignored when present; at the interactive prompt, they terminate multiline state- ments. Reminder: the ... continuation line prompt in the preceding is printed by Python automatically as a visual guide; it may not appear in your interface (e.g., IDLE), and is sometimes omitted by this book, but do not type it yourself if it’s absent. Also bear in mind that the interactive prompt runs just one statement at a time: you must press Enter twice to run a loop or other multiline statement before you can type the next statement: The Interactive Prompt | 53
- 106. >>> for x in 'spam': ... print(x) # Press Enter twice before a new statement ... print('done') File "<stdin>", line 3 print('done') ^ SyntaxError: invalid syntax This means you can’t cut and paste multiple lines of code into the interactive prompt, unless the code includes blank lines after each compound statement. Such code is better run in a file—which brings us to the next section’s topic. System Command Lines and Files Although the interactive prompt is great for experimenting and testing, it has one big disadvantage: programs you type there go away as soon as the Python interpreter ex- ecutes them. Because the code you type interactively is never stored in a file, you can’t run it again without retyping it from scratch. Cut-and-paste and command recall can help some here, but not much, especially when you start writing larger programs. To cut and paste code from an interactive session, you would have to edit out Python prompts, program outputs, and so on—not exactly a modern software development methodology! To save programs permanently, you need to write your code in files, which are usually known as modules. Modules are simply text files containing Python statements. Once they are coded, you can ask the Python interpreter to execute the statements in such a file any number of times, and in a variety of ways—by system command lines, by file icon clicks, by options in the IDLE user interface, and more. Regardless of how it is run, Python executes all the code in a module file from top to bottom each time you run the file. Terminology in this domain can vary somewhat. For instance, module files are often referred to as programs in Python—that is, a program is considered to be a series of precoded statements stored in a file for repeated execution. Module files that are run directly are also sometimes called scripts—an informal term usually meaning a top-level program file. Some reserve the term “module” for a file imported from another file, and “script” for the main file of a program; we generally will here, too (though you’ll have to stay tuned for more on the meaning of “top-level,” imports, and main files later in this chapter). Whatever you call them, the next few sections explore ways to run code typed into module files. In this section, you’ll learn how to run files in the most basic way: by listing their names in a python command line entered at your computer’s system prompt. Though it might seem primitive to some—and can often be avoided altogether by using a GUI like IDLE, discussed later—for many programmers a system shell com- mand-line window, together with a text editor window, constitutes as much of an 54 | Chapter 3: How You Run Programs
- 107. integrated development environment as they will ever need, and provides more direct control over programs. A First Script Let’s get started. Open your favorite text editor (e.g., vi, Notepad, or the IDLE editor), type the following statements into a new text file named script1.py, and save it in your working code directory that you set up earlier: # A first Python script import sys # Load a library module print(sys.platform) print(2 ** 100) # Raise 2 to a power x = 'Spam!' print(x * 8) # String repetition This file is our first official Python script (not counting the two-liner in Chapter 2). You shouldn’t worry too much about this file’s code, but as a brief description, this file: • Imports a Python module (libraries of additional tools), to fetch the name of the platform • Runs three print function calls, to display the script’s results • Uses a variable named x, created when it’s assigned, to hold onto a string object • Applies various object operations that we’ll begin studying in the next chapter The sys.platform here is just a string that identifies the kind of computer you’re work- ing on; it lives in a standard Python module called sys, which you must import to load (again, more on imports later). For color, I’ve also added some formal Python comments here—the text after the # characters. I mentioned these earlier, but should be more formal now that they’re showing up in scripts. Comments can show up on lines by themselves, or to the right of code on a line. The text after a # is simply ignored as a human-readable comment and is not considered part of the statement’s syntax. If you’re copying this code, you can ignore the comments; they are just informative. In this book, we usually use a different formatting style to make comments more visually distinctive, but they’ll ap- pear as normal text in your code. Again, don’t focus on the syntax of the code in this file for now; we’ll learn about all of it later. The main point to notice is that you’ve typed this code into a file, rather than at the interactive prompt. In the process, you’ve coded a fully functional Python script. Notice that the module file is called script1.py. As for all top-level files, it could also be called simply script, but files of code you want to import into a client have to end with a .py suffix. We’ll study imports later in this chapter. Because you may want to import them in the future, it’s a good idea to use .py suffixes for most Python files that you code. Also, some text editors detect Python files by their .py suffix; if the suffix is not present, you may not get features like syntax colorization and automatic indentation. System Command Lines and Files | 55
- 108. Running Files with Command Lines Once you’ve saved this text file, you can ask Python to run it by listing its full filename as the first argument to a python command like the following typed at the system shell prompt (don’t type this at Python’s interactive prompt, and read on to the next para- graph if this doesn’t work right away for you): % python script1.py win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! Again, you can type such a system shell command in whatever your system provides for command-line entry—a Windows Command Prompt window, an xterm window, or similar. But be sure to run this in the same working directory where you’ve saved your script file (“cd” there first if needed), and be sure to run this at the system prompt, not Python’s “>>>” prompt. Also remember to replace the command’s word “python” with a full directory path as we did before if your PATH setting is not configured, though this isn’t required for the “py” Windows launcher program, and may not be required in 3.3 and later. Another note to beginners: do not type any of the preceding text in the script1.py source file you created in the prior section. This text is a system command and program output, not program code. The first line here is the shell command used to run the source file, and the lines following it are the results produced by the source file’s print statements. And again, remember that the % stands for the system prompt—don’t type it yourself (not to nag, but it’s a remarkably common early mistake). If all works as planned, this shell command makes Python run the code in this file line by line, and you will see the output of the script’s three print statements—the name of the underlying platform as known Python, 2 raised to the power 100, and the result of the same string repetition expression we saw earlier (again, more on the meaning of the last two of these in Chapter 4). If all didn’t work as planned, you’ll get an error message—make sure you’ve entered the code in your file exactly as shown, and try again. The next section has additional options and pointers on this process, and we’ll talk about debugging options in the sidebar “Debugging Python Code” on page 83, but at this point in the book your best bet is probably rote imitation. And if all else fails, you might also try running under the IDLE GUI discussed ahead—a tool that sugarcoats some launching details, though sometimes at the expense of the more explicit control you have when using command lines. You can also fetch the code examples off the Web if copying grows too tedious or error- prone, though typing some code initially will help you learn to avoid syntax errors. See the preface for details on how to obtain the book’s example files. 56 | Chapter 3: How You Run Programs
- 109. Command-Line Usage Variations Because this scheme uses shell command lines to start Python programs, all the usual shell syntax applies. For instance, you can route the printed output of a Python script to a file to save it for later use or inspection by using special shell syntax: % python script1.py > saveit.txt In this case, the three output lines shown in the prior run are stored in the file sa- veit.txt instead of being printed. This is generally known as stream redirection; it works for input and output text and is available on Windows and Unix-like systems. This is nice for testing, as you can write programs that watch for changes in other programs’ outputs. It also has little to do with Python, though (Python simply supports it), so we will skip further details on shell redirection syntax here. If you are working on a Windows platform, this example works the same, but the system prompt is normally different as described earlier: C:code> python script1.py win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! As usual, if you haven’t set your PATH environment variable to include the full directory path to python, be sure to include this in your command, or run a change-directory command to go to the path first: C:code> C:python33python script1.py win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! Alternatively, if you’re using the Windows launcher new in Python 3.3 (described ear- lier), a py command will have the same effect, but does not require a directory path or PATH settings, and allows you to specify Python version numbers on the command line too: c:code> py −3 script1.py win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! On all recent versions of Windows, you can also type just the name of your script, and omit the name of Python itself. Because newer Windows systems use the Windows Registry (a.k.a. filename associations) to find a program with which to run a file, you don’t need to name “python” or “py” on the command line explicitly to run a .py file. The prior command, for example, could be simplified to the following on most Win- dows machines, and will automatically be run by python prior to 3.3, and by py in 3.3 and later—just as though you had clicked on the file’s icon in Explorer (more on this option ahead): C:code> script1.py System Command Lines and Files | 57
- 110. Finally, remember to give the full path to your script file if it lives in a different directory from the one in which you are working. For example, the following system command line, run from D:other, assumes Python is in your system path but runs a file located elsewhere: C:code> cd D:other D:other> python c:codescript1.py If your PATH doesn’t include Python’s directory, you’re not using the Windows launcher’s py program, and neither Python nor your script file is in the directory you’re working in, use full paths for both: D:other> C:Python33python c:codescript1.py Usage Notes: Command Lines and Files Running program files from system command lines is a fairly straightforward launch option, especially if you are familiar with command lines in general from prior work. It’s also perhaps the most portable way to run Python programs since nearly every computer has some notion of a command line and directory structure. For newcomers, though, here are a few pointers about common beginner traps that might help you avoid some frustration: • Beware of automatic extensions on Windows and IDLE. If you use the Note- pad program to code program files on Windows, be careful to pick the type All Files when it comes time to save your file, and give the file a .py suffix explicitly. Otherwise, Notepad will save your file with a .txt extension (e.g., as script1.py.txt), making it difficult to use in some schemes; it won’t be importable, for example. Worse, Windows hides file extensions by default, so unless you have changed your view options you may not even notice that you’ve coded a text file and not a Python file. The file’s icon may give this away—if it doesn’t have a snake of some sort on it, you may have trouble. Uncolored code in IDLE and files that open to edit instead of run when clicked are other symptoms of this problem. Microsoft Word similarly adds a .doc extension by default; much worse, it adds formatting characters that are not legal Python syntax. As a rule of thumb, always pick All Files when saving under Windows, or use a more programmer-friendly text editor such as IDLE. IDLE does not even add a .py suffix automatically—a feature some programmers tend to like, but some users do not. • Use file extensions and directory paths at system prompts, but not for im- ports. Don’t forget to type the full name of your file in system command lines— that is, use python script1.py rather than python script1. By contrast, Python’s import statements, which we’ll meet later in this chapter, omit both the .py file suffix and the directory path (e.g., import script1). This may seem trivial, but confusing these two is a common mistake. 58 | Chapter 3: How You Run Programs
- 111. At the system prompt, you are in a system shell, not Python, so Python’s module file search rules do not apply. Because of that, you must include both the .py ex- tension and, if necessary, the full directory path leading to the file you wish to run. For instance, to run a file that resides in a different directory from the one in which you are working, you would typically list its full path (e.g., python d:tests spam.py). Within Python code, however, you can just say import spam and rely on the Python module search path to locate your file, as described later. • Use print statements in files. Yes, we’ve already been over this, but it is such a common mistake that it’s worth repeating at least once here. Unlike in interactive coding, you generally must use print statements to see output from program files. If you don’t see any output, make sure you’ve said “print” in your file. print state- ments are not required in an interactive session, since Python automatically echoes expression results; prints don’t hurt here, but are superfluous typing. Unix-Style Executable Scripts: #! Our next launching technique is really a specialized form of the prior, which, despite this section’s title, can apply to program files run on both Unix and Windows today. Since it has its roots on Unix, let’s begin this story there. Unix Script Basics If you are going to use Python on a Unix, Linux, or Unix-like system, you can also turn files of Python code into executable programs, much as you would for programs coded in a shell language such as csh or ksh. Such files are usually called executable scripts. In simple terms, Unix-style executable scripts are just normal text files containing Python statements, but with two special properties: • Their first line is special. Scripts usually start with a line that begins with the characters #! (often called “hash bang” or “shebang”), followed by the path to the Python interpreter on your machine. • They usually have executable privileges. Script files are usually marked as ex- ecutable to tell the operating system that they may be run as top-level programs. On Unix systems, a command such as chmod +x file.py usually does the trick. Let’s look at an example for Unix-like systems. Use your text editor again to create a file of Python code called brian: #!/usr/local/bin/python print('The Bright Side ' + 'of Life...') # + means concatenate for strings The special line at the top of the file tells the system where the Python interpreter lives. Technically, the first line is a Python comment. As mentioned earlier, all comments in Python programs start with a # and span to the end of the line; they are a place to insert extra information for human readers of your code. But when a comment such as the Unix-Style Executable Scripts: #! | 59
- 112. first line in this file appears, it’s special on Unix because the operating system shell uses it to find an interpreter for running the program code in the rest of the file. Also, note that this file is called simply brian, without the .py suffix used for the module file earlier. Adding a .py to the name wouldn’t hurt (and might help you remember that this is a Python program file), but because you don’t plan on letting other modules importthecodeinthisfile,thenameofthefileisirrelevant.Ifyougivethefileexecutable privileges with a chmod +x brian shell command, you can run it from the operating system shell as though it were a binary program (for the following, either make sure ., the current directory, is in your system PATH setting, or run this with ./brian): % brian The Bright Side of Life... The Unix env Lookup Trick On some Unix systems, you can avoid hardcoding the path to the Python interpreter in your script file by writing the special first-line comment like this: #!/usr/bin/env python ...script goes here... When coded this way, the env program locates the Python interpreter according to your system search path settings (in most Unix shells, by looking in all the directories listed in your PATH environment variable). This scheme can be more portable, as you don’t need to hardcode a Python install path in the first line of all your scripts. That way, if your scripts ever move to a new machine, or your Python ever moves to a new location, you must update just PATH, not all your scripts. Provided you have access to env everywhere, your scripts will run no matter where Python lives on your system. In fact, this env form is generally recommended today over even something as generic as /usr/bin/python, because some platforms may install Python elsewhere. Of course, this assumes that env lives in the same place everywhere (on some machines, it may be in /sbin, /bin, or elsewhere); if not, all portability bets are off! The Python 3.3 Windows Launcher: #! Comes to Windows A note for Windows users running Python 3.2 and earlier: the method described here is a Unix trick, and it may not work on your platform. Not to worry; just use the basic command-line technique explored earlier. List the file’s name on an explicit python command line:1 C:code> python brian The Bright Side of Life... In this case, you don’t need the special #! comment at the top (although Python just ignores it if it’s present), and the file doesn’t need to be given executable privileges. In fact, if you want to run files portably between Unix and Microsoft Windows, your life 60 | Chapter 3: How You Run Programs
- 113. will probably be simpler if you always use the basic command-line approach, not Unix- style scripts, to launch programs. If you’re using Python 3.3 or later, though, or have its Windows launcher installed separately, it turns out that Unix-style #! lines do mean something on Windows too. Besides offering the py executable described earlier, the new Windows launcher men- tioned earlier attempts to parse #! lines to determine which Python version to launch to run your script’s code. Moreover, it allows you to give the version number in full or partial forms, and recognizes most common Unix patterns for this line, including the /usr/bin/env form. The launcher’s #! parsing mechanism is applied when you run scripts from command lines with the py program, and when you click Python file icons (in which case py is run implicitly by filename associations). Unlike Unix, you do not need to mark files with executable privileges for this to work on Windows, because filename associations ach- ieve similar results. For example, the first of the following is run by Python 3.X and the second by 2.X (without an explicit number, the launcher defaults to 2.X unless you set a PY_PYTHON environment variable): c:code> type robin3.py #!/usr/bin/python3 print('Run', 'away!...') # 3.X function c:code> py robin3.py # Run file per #! line version Run away!... c:code> type robin2.py #!python2 print 'Run', 'away more!...' # 2.X statement c:code> py robin2.py # Run file per #! line version Run away more!... This works in addition to passing versions on command lines—we saw this briefly earlier for starting the interactive prompt, but it works the same when launching a script file: c:code> py −3.1 robin3.py # Run per command-line argument Run away!... The net effect is that the launcher allows Python versions to be specified on both a per- file and per-command basis, by using #! lines and command-line arguments, respec- 1. As we discussed when exploring command lines, all recent Windows versions also let you type just the name of a .py file at the system command line—they use the Registry to determine that the file should be opened with Python (e.g., typing brian.py is equivalent to typing python brian.py). This command-line mode is similar in spirit to the Unix #!, though it is system-wide on Windows, not per-file. It also requires an explicit .py extension: filename associations won’t work without it. Some programs may actually interpret and use a first #! line on Windows much like on Unix (including Python 3.3’s Windows launcher), but the system shell on Windows itself simply ignores it. Unix-Style Executable Scripts: #! | 61
- 114. tively.Atleastthat’stheveryshortversionofthelauncher’sstory.Ifyou’reusingPython 3.3 or later on Windows or may in the future, I recommend a side trip to the full launcher story in Appendix B if you haven’t made one already. Clicking File Icons If you’re not a fan of command lines, you can generally avoid them by launching Python scripts with file icon clicks, development GUIs, and other schemes that vary per plat- form. Let’s take a quick look at the first of these alternatives here. Icon-Click Basics Icon clicks are supported on most platforms in one form or another. Here’s a rundown of how these might be structured on your computer: Windows icon clicks On Windows, the Registry makes opening files with icon clicks easy. When in- stalled, Python uses Windows filename associations to automatically register itself to be the program that opens Python program files when they are clicked. Because of that, it is possible to launch the Python programs you write by simply clicking (or double-clicking) on their file icons with your mouse cursor. Specifically, a clicked file will be run by one of two Python programs, depending on its extension and the Python you’re running. In Pythons 3.2 and earlier, .py files are run by python.exe with a console (Command Prompt) window, and .pyw files are run by pythonw.exe files without a console. Byte code files are also run by these programs if clicked. Per Appendix B, in Python 3.3 and later (and where it’s in- stalled separately), the new Window’s launchers’s py.exe and pyw.exe programs serve the same roles, opening .py and .pyw files, respectively. Non-Windows icon clicks On non-Windows systems, you will probably be able to perform a similar feat, but the icons, file explorer navigation schemes, and more may differ slightly. On Mac OS X, for instance, you might use PythonLauncher in the MacPython (or Python N.M) folder of your Applications folder to run by clicking in Finder. On some Linux and other Unix systems, you may need to register the .py extension with your file explorer GUI, make your script executable using the #! line scheme of the preceding section, or associate the file MIME type with an application or command by editing files, installing programs, or using other tools. See your file explorer’s documentation for more details. In other words, icon clicks generally work as you’d expect for your platform, but be sure to see the platform usage documentation “Python Setup and Usage” in Python’s standard manual set for more details as needed. 62 | Chapter 3: How You Run Programs
- 115. Clicking Icons on Windows To illustrate, let’s keep using the script we wrote earlier, script1.py, repeated here to minimize page flipping: # A first Python script import sys # Load a library module print(sys.platform) print(2 ** 100) # Raise 2 to a power x = 'Spam!' print(x * 8) # String repetition As we’ve seen, you can always run this file from a system command line: C:code> python script1.py win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! However, icon clicks allow you to run the file without any typing at all. To do so, you have to find this file’s icon on your computer. On Windows 8, you might right-click the screen’s lower-left corner to open a File Explorer. On earlier Windows, you can select Computer (or My Computer in XP) in your Start button’s menu. There are ad- ditional ways to open a file explorer; once you do, work your way down on the C drive to your working directory. At this point, you should have a file explorer window similar to that captured in Fig- ure 3-1 (Windows 8 is being used here). Notice how the icons for Python files show up: • Source files have white backgrounds on Windows. • Byte code files show with black backgrounds. Per the prior chapter, I created the byte code file in this figure by importing in Python 3.1; 3.2 and later instead store byte code files in the __pycache__ subdirectory also shown here, which I created by importing in 3.3 too. You will normally want to click (or otherwise run) the white source code files in order to pick up your most recent changes, not the byte code files—Python won’t check the source code file for changes if you launch byte code directly. To launch the file here, simply click on the icon for script1.py. The input Trick on Windows Unfortunately, on Windows, the result of clicking on a file icon may not be incredibly satisfying. In fact, as it is, this example script might generate a perplexing “flash” when clicked—not exactly the sort of feedback that budding Python programmers usually hope for! This is not a bug, but has to do with the way the Windows version of Python handles printed output. By default, Python generates a pop-up black DOS console window (Command Prompt) to serve as a clicked file’s input and output. If a script just prints and exits, well, it just Clicking File Icons | 63
- 116. prints andexits—the consolewindowappears,andtextisprintedthere,buttheconsole window closes and disappears on program exit. Unless you are very fast, or your ma- chine is very slow, you won’t get to see your output at all. Although this is normal behavior, it’s probably not what you had in mind. Luckily, it’s easy to work around this. If you need your script’s output to stick around when you launch it with an icon click, simply put a call to the built-in input function at the very bottom of the script in 3.X (in 2.X use the name raw_input instead: see the note ahead). For example: # A first Python script import sys # Load a library module print(sys.platform) print(2 ** 100) # Raise 2 to a power x = 'Spam!' print(x * 8) # String repetition input() # <== ADDED In general, input reads and returns the next line of standard input, waiting if there is none yet available. The net effect in this context will be to pause the script, thereby keeping the output window shown in Figure 3-2 open until you press the Enter key. Now that I’ve shown you this trick, keep in mind that it is usually only required for Windows, and then only if your script prints text and exits and only if you will launch the script by clicking its file icon. You should add this call to the bottom of your top- level files if and only if all of these three conditions apply. There is no reason to add this call in any other contexts, such as scripts you’ll run in command lines or the IDLE GUI (unless you’re unreasonably fond of pressing your computer’s Enter key!).2 That may sound obvious, but it’s been another common mistake in live classes. Figure 3-1. On Windows, Python program files show up as icons in file explorer windows and can automatically be run with a double-click of the mouse (though you might not see printed output or error messages this way). 64 | Chapter 3: How You Run Programs
- 117. Before we move ahead, note that the input call applied here is the input counterpart of using the print function (and 2.X statement) for outputs. It is the simplest way to read user input, and it is more general than this example implies. For instance, input: • Optionally accepts a string that will be printed as a prompt (e.g., input('Press Enter to exit')) • Returns to your script a line of text read as a string (e.g., nextinput = input()) • Supports input stream redirections at the system shell level (e.g., python spam.py < input.txt), just as the print statement does for output We’ll use input in more advanced ways later in this text; for instance, Chapter 10 will apply it in an interactive loop. For now, it will help you see the output of simple scripts that you click to launch. Version skew note: If you are working in Python 2.X, use raw_input() instead of input() in this code. The former was renamed to the latter in Python 3.X. Technically, 2.X has an input function too, but it also eval- uates strings as though they are program code typed into a script, and so will not work in this context (an empty string is an error). Python 3.X’s input (and 2.X’s raw_input) simply returns the entered text as a character string, unevaluated. To simulate 2.X’s input in 3.X, use eval(input()). Be aware, though, that because this runs the entered text as though it were program code, this may have security implications that we’ll largely Figure 3-2. When you click a program’s icon on Windows, you will be able to see its printed output if you include an input call at the very end of the script. But you only need to do so in this one context! 2. Conversely, it is also possible to completely suppress the pop-up console window (a.k.a. Command Prompt) for clicked files on Windows when you don’t want to see printed text. Files whose names end in a .pyw extension will display only windows constructed by your script, not the default console window. .pyw files are simply .py source files that have this special operational behavior on Windows. They are mostly used for Python-coded user interfaces that build windows of their own, often in conjunction with various techniques for saving printed output and errors to files. As implied earlier, Python achieves this when it is installed by associating a special executable (pythonw.exe in 3.2 and earlier and pyw.exe as of 3.3) to open .pyw files when clicked. Clicking File Icons | 65
- 118. ignore here, except to say that you should trust the source of the entered text; if you don’t, stick to just plain input in 3.X and raw_input in 2.X. Other Icon-Click Limitations Even with the prior section’s input trick, clicking file icons is not without its perils. You also may not get to see Python error messages. If your script generates an error, the error message text is written to the pop-up console window—which then immediately disappears! Worse, adding an input call to your file will not help this time because your script will likely abort long before it reaches this call. In other words, you won’t be able to tell what went wrong. When we discuss exceptions later in this book, you’ll learn that it is possible to write code to intercept, process, and recover from errors so that they do not terminate your programs. Watch for the discussion of the try statement later in this book for an al- ternative way to keep the console window from closing on errors. We’ll also learn how to redirect printed text to files for later inspection when we study print operations. Barring such support in your code, though, errors and prints disappear for clicked programs. Because of these limitations, it is probably best to view icon clicks as a way to launch programs after they have been debugged, or have been instrumented to write their output to a file and catch and process any important errors. Especially when you’re starting out, I recommend using other techniques—such as system command lines and IDLE (discussed further in the section “The IDLE User Interface” on page 73)—so that you can see generated error messages and view your normal output without re- sorting to extra coding. Module Imports and Reloads So far, I’ve been talking about “importing modules” without really explaining what this term means. We’ll study modules and larger program architecture in depth in Part V, but because imports are also a way to launch programs, this section will introduce enough module basics to get you started. Import and Reload Basics In simple terms, every file of Python source code whose name ends in a .py extension is a module. No special code or syntax is required to make a file a module: any such file will do. Other files can access the items a module defines by importing that module —import operations essentially load another file and grant access to that file’s contents. The contents of a module are made available to the outside world through its attributes (a term I’ll define in the next section). 66 | Chapter 3: How You Run Programs
- 119. This module-based services model turns out to be the core idea behind program archi- tectureinPython.Largerprogramsusuallytaketheformofmultiplemodulefiles,which import tools from other module files. One of the modules is designated as the main or top-level file, or “script”—the file launched to start the entire program, which runs line by line as usual. Below this level, it’s all modules importing modules. We’ll delve into such architectural issues in more detail later in this book. This chapter is mostly interested in the fact that import operations run the code in a file that is being loaded as a final step. Because of this, importing a file is yet another way to launch it. For instance, if you start an interactive session (from a system command line or other- wise), you can run the script1.py file you created earlier with a simple import (be sure to delete the input line you added in the prior section first, or you’ll need to press Enter for no reason): C:code> C:python33python >>> import script1 win32 1267650600228229401496703205376 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! This works, but only once per session (really, process—a program run) by default. After the first import, later imports do nothing, even if you change and save the module’s source file again in another window: ...Change script1.py in a text edit window to print 2 ** 16... >>> import script1 >>> import script1 This is by design; imports are too expensive an operation to repeat more than once per file, per program run. As you’ll learn in Chapter 22, imports must find files, compile them to byte code, and run the code. If you really want to force Python to run the file again in the same session without stopping and restarting the session, you need to instead call the reload function avail- able in the imp standard library module (this function is also a simple built-in in Python 2.X, but not in 3.X): >>> from imp import reload # Must load from module in 3.X (only) >>> reload(script1) win32 65536 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! <module 'script1' from '.script1.py'> >>> The from statement here simply copies a name out of a module (more on this soon). The reload function itself loads and runs the current version of your file’s code, picking up changes if you’ve modified and saved it in another window. Module Imports and Reloads | 67
- 120. This allows you to edit and pick up new code on the fly within the current Python interactive session. In this session, for example, the second print statement in script1.py was changed in another window to print 2 ** 16 between the time of the first import and the reload call—hence the different result. The reload function expects the name of an already loaded module object, so you have to have successfully imported a module once before you reload it (if the import reported an error, you can’t yet reload and must import again). Notice that reload also expects parentheses around the module object name, whereas import does not. reload is a function that is called, and import is a statement. That’s why you must pass the module name to reload as an argument in parentheses, and that’s why you get back an extra output line when reloading—the last output line is just the display representation of the reload call’s return value, a Python module object. We’ll learn more about using functions in general in Chapter 16; for now, when you hear “function,” remember that parentheses are required to run a call. Version skew note: Python 3.X moved the reload built-in function to the imp standard library module. It still reloads files as before, but you must import it in order to use it. In 3.X, run an import imp and use imp.reload(M), or run a from imp import reload and use reload(M), as shown here. We’ll discuss import and from statements in the next sec- tion, and more formally later in this book. If you are working in Python 2.X, reload is available as a built-in func- tion, so no import is required. In Python 2.6 and 2.7, reload is available in both forms—built-in and module function—to aid the transition to 3.X. In other words, reloading is still available in 3.X, but an extra line of code is required to fetch the reload call. The move in 3.X was likely motivated in part by some well-known issues involving reload and from statements that we’ll encounter in the next section. In short, names loaded with a from are not directly updated by a reload, but names accessed with an import statement are. If your names don’t seem to change after a reload, try using import and mod ule.attribute name references instead. The Grander Module Story: Attributes Imports and reloads provide a natural program launch option because import opera- tions execute files as a last step. In the broader scheme of things, though, modules serve the role of libraries of tools, as you’ll learn in detail in Part V. The basic idea is straight- forward, though: a module is mostly just a package of variable names, known as a namespace, and the names within that package are called attributes. An attribute is simply a variable name that is attached to a specific object (like a module). In more concrete terms, importers gain access to all the names assigned at the top level of a module’s file. These names are usually assigned to tools exported by the module 68 | Chapter 3: How You Run Programs
- 121. —functions, classes, variables, and so on—that are intended to be used in other files and other programs. Externally, a module file’s names can be fetched with two Python statements, import and from, as well as the reload call. To illustrate, use a text editor to create a one-line Python module file called myfile.py in your working directory, with the following contents: title = "The Meaning of Life" Thismaybeoneoftheworld’ssimplestPythonmodules(itcontainsasingleassignment statement), but it’s enough to illustrate the point. When this file is imported, its code is run to generate the module’s attribute. That is, the assignment statement creates a variable and module attribute named title. You can access this module’s title attribute in other components in two different ways. First, you can load the module as a whole with an import statement, and then qualify the module name with the attribute name to fetch it (note that we’re letting the inter- preter print automatically here): % python # Start Python >>> import myfile # Run file; load module as a whole >>> myfile.title # Use its attribute names: '.' to qualify 'The Meaning of Life' In general, the dot expression syntax object.attribute lets you fetch any attribute attached to any object, and is one of the most common operations in Python code. Here, we’ve used it to access the string variable title inside the module myfile—in other words, myfile.title. Alternatively, you can fetch (really, copy) names out of a module with from statements: % python # Start Python >>> from myfile import title # Run file; copy its names >>> title # Use name directly: no need to qualify 'The Meaning of Life' As you’ll see in more detail later, from is just like an import, with an extra assignment to names in the importing component. Technically, from copies a module’s attributes, such that they become simple variables in the recipient—thus, you can simply refer to the imported string this time as title (a variable) instead of myfile.title (an attribute reference).3 Whether you use import or from to invoke an import operation, the statements in the module file myfile.py are executed, and the importing component (here, the interactive prompt) gains access to names assigned at the top level of the file. There’s only one such name in this simple example—the variable title, assigned to a string—but the 3. Notice that import and from both list the name of the module file as simply myfile without its .py extension suffix. As you’ll learn in Part V, when Python looks for the actual file, it knows to include the suffix in its search procedure. Again, you must include the .py suffix in system shell command lines, but not in import statements. Module Imports and Reloads | 69
- 122. concept will be more useful when you start defining objects such as functions and classes in your modules: such objects become reusable software components that can be accessed by name from one or more client modules. In practice, module files usually define more than one name to be used in and outside the files. Here’s an example that defines three: a = 'dead' # Define three attributes b = 'parrot' # Exported to other files c = 'sketch' print(a, b, c) # Also used in this file (in 2.X: print a, b, c) This file, threenames.py, assigns three variables, and so generates three attributes for the outside world. It also uses its own three variables in a 3.X print statement, as we see when we run this as a top-level file (in Python 2.X print differs slightly, so omit its outer parenthesis to match the output here exactly; watch for a more complete ex- planation of this in Chapter 11): % python threenames.py dead parrot sketch All of this file’s code runs as usual the first time it is imported elsewhere, by either an import or from. Clients of this file that use import get a module with attributes, while clients that use from get copies of the file’s names: % python >>> import threenames # Grab the whole module: it runs here dead parrot sketch >>> >>> threenames.b, threenames.c # Access its attributes ('parrot', 'sketch') >>> >>> from threenames import a, b, c # Copy multiple names out >>> b, c ('parrot', 'sketch') The results here are printed in parentheses because they are really tuples—a kind of object created by the comma in the inputs (and covered in the next part of this book) —that you can safely ignore for now. Once you start coding modules with multiple names like this, the built-in dir function starts to come in handy—you can use it to fetch a list of all the names available inside a module. The following returns a Python list of strings in square brackets (we’ll start studying lists in the next chapter): >>> dir(threenames) ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'b', 'c'] The contents of this list have been edited here because they vary per Python version. The point to notice here is that when the dir function is called with the name of an importedmodule in parentheseslikethis,itreturnsallthe attributesinsidethatmodule. Some of the names it returns are names you get “for free”: names with leading and trailing double underscores (__X__) are built-in names that are always predefined by 70 | Chapter 3: How You Run Programs
- 123. Python and have special meaning to the interpreter, but they aren’t important at this point in this book. The variables our code defined by assignment—a, b, and c—show up last in the dir result. Modules and namespaces Module imports are a way to run files of code, but, as we’ll expand on later in the book, modules are also the largest program structure in Python programs, and one of the first key concepts in the language. As we’ve seen, Python programs are composed of multiple module files linked together by import statements, and each module file is a package of variables—that is, a name- space. Just as importantly, each module is a self-contained namespace: one module file cannot see the names defined in another file unless it explicitly imports that other file. Because of this, modules serve to minimize name collisions in your code—because each file is a self-contained namespace, the names in one file cannot clash with those in another, even if they are spelled the same way. In fact, as you’ll see, modules are one of a handful of ways that Python goes to great lengths to package your variables into compartments to avoid name clashes. We’ll discuss modules and other namespace constructs—including local scopes defined by classes and functions—further later in the book. For now, modules will come in handy as a way to run your code many times without having to retype it, and will prevent your file’s names from accidentally replacing each other. import versus from: I should point out that the from statement in a sense defeats the namespace partitioning purpose of modules—because the from copies variables from one file to another, it can cause same-named variables in the importing file to be overwritten, and won’t warn you if it does. This essentially collapses namespaces together, at least in terms of the copied variables. Because of this, some recommend always using import instead of from. I won’t go that far, though; not only does from involve less typing (an asset at the interactive prompt), but its purported problem is relatively rare in practice. Besides, this is something you control by listing the variables you want in the from; as long as you understand that they’ll be assigned to values in the target module, this is no more dangerous than coding assignment statements—another feature you’ll probably want to use! Usage Notes: import and reload For some reason, once people find out about running files using import and reload, many tend to focus on this alone and forget about other launch options that always run the current version of the code (e.g., icon clicks, IDLE menu options, and system command lines). This approach can quickly lead to confusion, though—you need to Module Imports and Reloads | 71
- 124. remember when you’ve imported to know if you can reload, you need to remember to use parentheses when you call reload (only), and you need to remember to use reload in the first place to get the current version of your code to run. Moreover, reloads aren’t transitive—reloading a module reloads that module only, not any modules it may import—so you sometimes have to reload multiple files. Because of these complications (and others we’ll explore later, including the reload/ from issue mentioned briefly in a prior note in this chapter), it’s generally a good idea to avoid the temptation to launch by imports and reloads for now. The IDLE Run→Run Module menu option described in the next section, for example, provides a simpler and less error-prone way to run your files, and always runs the current version of your code. System shell command lines offer similar benefits. You don’t need to use reload if you use any of these other techniques. In addition, you may run into trouble if you use modules in unusual ways at this point in the book. For instance, if you want to import a module file that is stored in a directory other than the one you’re working in, you’ll have to skip ahead to Chapter 22 and learn about the module search path. For now, if you must import, try to keep all your files in the directory you are working in to avoid complications.4 That said, imports and reloads have proven to be a popular testing technique in Python classes, and you may prefer using this approach too. As usual, though, if you find yourself running into a wall, stop running into a wall! Using exec to Run Module Files Strictly speaking, there are more ways to run code stored in module files than have yet been presented here. For instance, the exec(open('module.py').read()) built-in func- tion call is another way to launch files from the interactive prompt without having to import and later reload. Each such exec runs the current version of the code read from a file, without requiring later reloads (script1.py is as we left it after a reload in the prior section): % python >>> exec(open('script1.py').read()) win32 65536 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! ...Change script1.py in a text edit window to print 2 ** 32... >>> exec(open('script1.py').read()) 4. Ifyou’retoocurioustowait,theshortstoryisthatPythonsearchesforimportedmodulesineverydirectory listed in sys.path—a Python list of directory name strings in the sys module, which is initialized from a PYTHONPATH environment variable, plus a set of standard directories. If you want to import from a directory other than the one you are working in, that directory must generally be listed in your PYTHONPATH setting. For more details, see Chapter 22 and Appendix A. 72 | Chapter 3: How You Run Programs
- 125. win32 4294967296 Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam! Theexec callhasaneffectsimilartoanimport,butitdoesn’tactuallyimportthemodule —by default, each time you call exec this way it runs the file’s code anew, as though you had pasted it in at the place where exec is called. Because of that, exec does not require module reloads after file changes—it skips the normal module import logic. On the downside, because it works as if you’ve pasted code into the place where it is called, exec, like the from statement mentioned earlier, has the potential to silently overwrite variables you may currently be using. For example, our script1.py assigns to a variable named x. If that name is also being used in the place where exec is called, the name’s value is replaced: >>> x = 999 >>> exec(open('script1.py').read()) # Code run in this namespace by default ...same output... >>> x # Its assignments can overwrite names here 'Spam!' By contrast, the basic import statement runs the file only once per process, and it makes the file a separate module namespace so that its assignments will not change variables in your scope. The price you pay for the namespace partitioning of modules is the need to reload after changes. Version skew note: Python 2.X also includes an execfile('module.py') built-in function, in addition to allowing the form exec(open('mod ule.py')), which both automatically read the file’s content. Both of these are equivalent to the exec(open('module.py').read()) form, which is more complex but runs in both 2.X and 3.X. Unfortunately, neither of these two simpler 2.X forms is available in 3.X, which means you must understand both files and their read methods to fully understand this technique today (this seems to be a case of aes- thetics trouncing practicality in 3.X). In fact, the exec form in 3.X in- volves so much typing that the best advice may simply be not to do it— it’s usually easier to launch files by typing system shell command lines or by using the IDLE menu options described in the next section. For more on the file interfaces used by the 3.X exec form, see Chap- ter 9. For more on exec and its cohorts, eval and compile, see Chap- ter 10 and Chapter 25. The IDLE User Interface So far, we’ve seen how to run Python code with the interactive prompt, system com- mand lines, Unix-style scripts, icon clicks, module imports, and exec calls. If you’re looking for something a bit more visual, IDLE provides a graphical user interface for The IDLE User Interface | 73
- 126. doing Python development, and it’s a standard and free part of the Python system. IDLE is usually referred to as an integrated development environment (IDE), because it binds together various development tasks into a single view.5 In short, IDLE is a desktop GUI that lets you edit, run, browse, and debug Python programs, all from a single interface. It runs portably on most Python platforms, in- cluding Microsoft Windows, X Windows (for Linux, Unix, and Unix-like platforms), and the Mac OS (both Classic and OS X). For many, IDLE represents an easy-to-use alternative to typing command lines, a less problem-prone alternative to clicking on icons, and a great way for newcomers to get started editing and running code. You’ll sacrifice some control in the bargain, but this typically becomes important later in your Python career. IDLE Startup Details Most readers should be able to use IDLE immediately, as it is a standard component on Mac OS X and most Linux installations today, and is installed automatically with standard Python on Windows. Because platforms specifics vary, though, I need to give a few pointers before we open the GUI. Technically, IDLE is a Python program that uses the standard library’s tkinter GUI toolkit (named Tkinter in Python 2.X) to build its windows. This makes IDLE portable —it works the same on all major desktop platforms—but it also means that you’ll need to have tkinter support in your Python to use IDLE. This support is standard on Win- dows, Macs, and Linux, but it comes with a few caveats on some systems, and startup can vary per platform. Here are a few platform-specific tips: • On Windows 7 and earlier, IDLE is easy to start—it’s always present after a Python install, and has an entry in the Start button menu for Python in Windows 7 and earlier (see Figure 2-1, shown previously). You can also select it by right-clicking on a Python program icon, and launch it by clicking on the icon for the files idle.pyw or idle.py located in the idlelib subdirectory of Python’s Lib directory. In this mode, IDLE is a clickable Python script that lives in C:Python33Libidlelib, C:Python27Libidlelib, or similar, which you can drag out to a shortcut for one- click access if desired. • On Windows 8, look for IDLE in your Start tiles, by a search for “idle,” by browsing your “All apps” Start screen display, or by using File Explorer to find the idle.py file mentioned earlier. You may want a shortcut here, as you have no Start button menu in desktop mode (at least today; see Appendix A for more pointers). • On Mac OS X everything required for IDLE is present as standard components in your operating system. IDLE should be available to launch in Applications under the MacPython (or Python N.M) program folder. One note here: some OS X ver- 5. IDLE is officially a corruption of IDE, but it’s really named in honor of Monty Python member Eric Idle. See Chapter 1 if you’re not sure why. 74 | Chapter 3: How You Run Programs
- 127. sions may require installing updated tkinter support due to subtle version depen- dencies I’ll spare readers from here; see python.org’s Download page for details. • On Linux IDLE is also usually present as a standard component today. It might take the form of an idle executable or script in your path; type this in a shell to check. On some machines, it may require an install (see Appendix A for pointers), and on others you may need to launch IDLE’s top-level script from a command line or icon click: run the file idle.py located in the idlelib subdirectory of Python’s /usr/lib directory (run a find for the exact location). Because IDLE is just a Python script on the module search path in the standard library, you can also generally run it on any platform and from any directory by typing the following in a system command shell window (e.g., in a Command Prompt on Win- dows), though you’ll have to see Appendix A for more on Python’s –m flag, and Part V for more on the “.” package syntax required here (blind trust will suffice at this point in the book): c:code> python -m idlelib.idle # Run idle.py in a package on module path For more on install issues and usage notes for Windows and other platforms, be sure to see both Appendix A as well as the notes for your platform in “Python Setup and Usage” in Python’s standard manuals. IDLE Basic Usage Let’s jump into an example. Figure 3-3 shows the scene after you start IDLE on Win- dows. The Python shell window that opens initially is the main window, which runs an interactive session (notice the >>> prompt). This works like all interactive sessions —code you type here is run immediately after you type it—and serves as a testing and experimenting tool. IDLE uses familiar menus with keyboard shortcuts for most of its operations. To make a new script file under IDLE, use File→New: in the main shell window, select the File pull-down menu, and pick New to open a new text edit window where you can type, save, and run your file’s code. Use File→Open... instead to open a new text edit window displaying an existing file’s code to edit and run. Although it may not show up fully in this book’s graphics, IDLE uses syntax-directed colorization for the code typed in both the main window and all text edit windows— keywords are one color, literals are another, and so on. This helps give you a better picture of the components in your code (and can even help you spot mistakes—run- on strings are all one color, for example). To run a file of code that you are editing in IDLE, use Run→Run Module in that file’s text edit window. That is, select the file’s text edit window, open that window’s Run pull-down menu, and choose the Run Module option listed there (or use the equivalent keyboard shortcut, given in the menu). Python will let you know that you need to save The IDLE User Interface | 75
- 128. your file first if you’ve changed it since it was opened or last saved and forgot to save your changes—a common mistake when you’re knee-deep in coding. When run this way, the output of your script and any error messages it may generate show up back in the main interactive window (the Python shell window). In Fig- ure 3-3, for example, the three lines after the “RESTART” line near the middle of the window reflect an execution of our script1.py file opened in a separate edit window. The “RESTART” message tells us that the user-code process was restarted to run the edited script and serves to separate script output (it does not appear if IDLE is started without a user-code subprocess—more on this mode in a moment). IDLE Usability Features Like most GUIs, the best way to learn IDLE may be to test-drive it for yourself, but some key usage points seem to be less than obvious. For example, if you want to repeat prior commands in IDLE’s main interactive window, you can use the Alt-P key combi- nation to scroll backward through the command history, and Alt-N to scroll forward (on some Macs, try Ctrl-P and Ctrl-N instead). Your prior commands will be recalled and displayed, and may be edited and rerun. Figure 3-3. The main Python shell window of the IDLE development GUI, shown here running on Windows. Use the File menu to begin (New Window) or change (Open...) a source file; use the text edit window’s Run menu to run the code in that window (Run Module). 76 | Chapter 3: How You Run Programs
- 129. You can also recall commands by positioning the cursor on them and clicking and pressing Enter to insert their text at the input prompt, or using standard cut-and-paste operations, though these techniques tend to involve more steps (and can sometimes be triggered accidentally). Outside IDLE, you may be able to recall commands in an in- teractive session with the arrow keys on Windows. Besides command history and syntax colorization, IDLE has additional usability fea- tures such as: • Auto-indent and unindent for Python code in the editor (Backspace goes back one level) • Word auto-completion while typing, invoked by a Tab press • Balloon help pop ups for a function call when you type its opening “(” • Pop-up selection lists of object attributes when you type a “.” after an object’s name and either pause or press Tab Some of these may not work on every platform, and some can be configured or disabled if you find that their defaults get in the way of your personal coding style. Advanced IDLE Tools Besides the basic edit and run functions and the prior section’s usability tools, IDLE provides more advanced features, including a point-and-click program graphical de- bugger and an object browser. The IDLE debugger is enabled via the Debug menu and the object browser via the File menu. The browser allows you to navigate through the module search path to files and objects in files; clicking on a file or object opens the corresponding source in a text edit window. You initiate IDLE debugging by selecting the Debug→Debugger menu option in the main window and then starting your script by selecting the Run→Run Module option in the text edit window; once the debugger is enabled, you can set breakpoints in your code that stop its execution by right-clicking on lines in the text edit windows, show variable values, and so on. You can also watch program execution when debugging— the current line of code is noted as you step through your code. For simpler debugging operations, you can also right-click with your mouse on the text of an error message to quickly jump to the line of code where the error occurred—a trick that makes it simple and fast to repair and run again. In addition, IDLE’s text editor offers a large collection of programmer-friendly tools, including advanced text and file search operations we won’t cover here. Because IDLE uses intuitive GUI in- teractions, you should experiment with the system live to get a feel for its other tools. The IDLE User Interface | 77
- 130. Usage Notes: IDLE IDLE is free, easy to use, portable, and automatically available on most platforms. I generally recommend it to Python newcomers because it simplifies some startup details and does not assume prior experience with system command lines. However, it is somewhat limited compared to more advanced commercial IDEs, and may seem heav- ier than a command line to some. To help you avoid some common pitfalls, here is a list of issues that IDLE beginners should bear in mind: • You must add “.py” explicitly when saving your files. I mentioned this when talking about files in general, but it’s a common IDLE stumbling block, especially for Windows users. IDLE does not automatically add a .py extension to filenames when files are saved. Be careful to type the .py extension yourself when saving a file for the first time. If you don’t, while you will be able to run your file from IDLE (and system command lines), you will not be able to import it either interactively or from other modules. • Run scripts by selecting Run→Run Module in text edit windows, not by in- teractive imports and reloads. Earlier in this chapter, we saw that it’s possible to run a file by importing it interactively. However, this scheme can grow complex because it requires you to manually reload files after changes. By contrast, using the Run→Run Module menu option in IDLE always runs the most current version of your file, just like running it using a system shell command line. IDLE also prompts you to save your file first, if needed (another common mistake outside IDLE). • You need to reload only modules being tested interactively. Like system shell command lines, IDLE’s Run→Run Module menu option always runs the current version of both the top-level file and any modules it imports. Because of this, Run→Run Module eliminates common confusions surrounding imports. You need to reload only modules that you are importing and testing interactively in IDLE. If you choose to use the import and reload technique instead of Run→Run Module, remember that you can use the Alt-P/Alt-N key combinations to recall prior com- mands. • You can customize IDLE. To change the text fonts and colors in IDLE, select the Configure option in the Options menu of any IDLE window. You can also cus- tomize key combination actions, indentation settings, autocompletions, and more; see IDLE’s Help pull-down menu for more hints. • There is currently no clear-screen option in IDLE. This seems to be a frequent request (perhaps because it’s an option available in similar IDEs), and it might be added eventually. Today, though, there is no way to clear the interactive window’s text. If you want the window’s text to go away, you can either press and hold the Enter key, or type a Python loop to print a series of blank lines (nobody really uses the latter technique, of course, but it sounds more high-tech than pressing the Enter key!). 78 | Chapter 3: How You Run Programs
- 131. • tkinter GUI and threaded programs may not work well with IDLE. Because IDLE is a Python/tkinter program, it can hang if you use it to run certain types of advanced Python/tkinter programs. This has become less of an issue in more recent versions of IDLE that run user code in one process and the IDLE GUI itself in another, but some programs (especially those that use multithreading) might still hang the GUI. Even just calling the tkinter quit function in your code, the normal way to exit a GUI program, may be enough to cause your program’s GUI to hang if run in IDLE (destroy may be better here only). Your code may not exhibit such problems, but as a rule of thumb, it’s always safe to use IDLE to edit GUI programs but launch them using other options, such as icon clicks or system command lines. When in doubt, if your code fails in IDLE, try it outside the GUI. • If connection errors arise, try starting IDLE in single-process mode. This issue appears to have gone away in recent Pythons, but may still impact readers using older versions. Because IDLE requires communication between its separate user and GUI processes, it can sometimes have trouble starting up on certain plat- forms (notably, it fails to start occasionally on some Windows machines, due to firewall software that blocks connections). If you run into such connection errors, it’s always possible to start IDLE with a system command line that forces it to run in single-process mode without a user-code subprocess and therefore avoids com- munication issues: its -n command-line flag forces this mode. On Windows, for example, start a Command Prompt window and run the system command line idle.py -n from within the directory C:Python33Libidlelib (cd there first if needed). A python -m idlelib.idle –n command works from anywhere (see Ap- pendix A for –m). • Beware of some IDLE usability features. IDLE does much to make life easier for beginners, but some of its tricks won’t apply outside the IDLE GUI. For in- stance, IDLE runs your scripts in its own interactive namespace, so variables in your code show up automatically in the IDLE interactive session—you don’t al- ways need to run import commands to access names at the top level of files you’ve already run. This can be handy, but it can also be confusing, because outside the IDLE environment names must always be imported from files explicitly to be used. When you run a file of code, IDLE also automatically changes to that file’s direc- tory and adds it to the module import search path—a handy feature that allows you to use files and import modules there without search path settings, but also something that won’t work the same when you run files outside IDLE. It’s OK to use such features, but don’t forget that they are IDLE behavior, not Python be- havior. Other IDEs Because IDLE is free, portable, and a standard part of Python, it’s a nice first develop- ment tool to become familiar with if you want to use an IDE at all. Again, I recommend Other IDEs | 79
- 132. that you use IDLE for this book’s exercises if you’re just starting out, unless you are already familiar with and prefer a command-line-based development mode. There are, however, a handful of alternative IDEs for Python developers, some of which are sub- stantially more powerful and robust than IDLE. Apart from IDLE, here are some of Python’s most commonly used IDEs: Eclipse and PyDev Eclipse is an advanced open source IDE GUI. Originally developed as a Java IDE, Eclipse also supports Python development when you install the PyDev (or a similar) plug-in. Eclipse is a popular and powerful option for Python development, and it goes well beyond IDLE’s feature set. It includes support for code completion, syn- tax highlighting, syntax analysis, refactoring, debugging, and more. Its downsides are that it is a large system to install and may require shareware extensions for some features (this may vary over time). Still, when you are ready to graduate from IDLE, the Eclipse/PyDev combination is worth your attention. Komodo A full-featured development environment GUI for Python (and other languages), Komodo includes standard syntax coloring, text editing, debugging, and other features. In addition, Komodo offers many advanced features that IDLE does not, including project files, source-control integration, and regular-expression debug- ging. At this writing, Komodo is not free, but see the Web for its current status— it is available at http://www.activestate.com from ActiveState, which also offers the ActivePython distribution package mentioned in Appendix A. NetBeans IDE for Python NetBeans is a powerful open source development environment GUI with support for many advanced features for Python developers: code completion, automatic indentation and code colorization, editor hints, code folding, refactoring, debug- ging, code coverage and testing, projects, and more. It may be used to develop both CPython and Jython code. Like Eclipse, NetBeans requires installation steps be- yond those of the included IDLE GUI, but it is seen by many as more than worth the effort. Search the Web for the latest information and links. PythonWin PythonWin is a free Windows-only IDE for Python that ships as part of Active- State’s ActivePython distribution (and may also be fetched separately from http:// www.python.org resources). It is roughly like IDLE, with a handful of useful Win- dows-specific extensions added; for example, PythonWin has support for COM objects. Today, IDLE is probably more advanced than PythonWin (for instance, IDLE’s dual-process architecture often prevents it from hanging). However, Py- thonWin still offers tools for Windows developers that IDLE does not. See http:// www.activestate.com for more information. Wing, Visual Studio, and others Other IDEs are popular among Python developers too, including the mostly com- mercial Wing IDE, Microsoft Visual Studio via a plug-in, and PyCharm, PyScrip- 80 | Chapter 3: How You Run Programs
- 133. ter, Pyshield, and Spyder—but I do not have space to do justice to them here, and morewillundoubtedlyappearovertime.Infact,almosteveryprogrammer-friendly text editor has some sort of support for Python development these days, whether it be preinstalled or fetched separately. Emacs and Vim, for instance, have sub- stantial Python support. IDE choices are often subjective, so I encourage you to browse to find tools that fit your development style and goals. For more information, see the resources available at http://www.python.org or search the Web for “Python IDE” or similar. A search for “Python editors” today leads you to a wiki page that maintains infor- mation about dozens of IDE and text-editor options for Python programming. Other Launch Options At this point, we’ve seen how to run code typed interactively, and how to launch code saved in files in a variety of ways—system command lines, icon clicks, imports and execs, GUIs like IDLE, and more. That covers most of the techniques in common use, and enough to run the code you’ll see in this book. There are additional ways to run Python code, though, most of which have special or narrow roles. For completeness and reference, the next few sections take a quick look at some of these. Embedding Calls In some specialized domains, Python code may be run automatically by an enclosing system. In such cases, we say that the Python programs are embedded in (i.e., run by) another program. The Python code itself may be entered into a text file, stored in a database, fetched from an HTML page, parsed from an XML document, and so on. But from an operational perspective, another system—not you—may tell Python to run the code you’ve created. Such an embedded execution mode is commonly used to support end-user customi- zation—a game program, for instance, might allow for play modifications by running user-accessible embedded Python code at strategic points in time. Users can modify this type of system by providing or changing Python code. Because Python code is interpreted, there is no need to recompile the entire system to incorporate the change (see Chapter 2 for more on how Python code is run). In this mode, the enclosing system that runs your code might be written in C, C++, or even Java when the Jython system is used. As an example, it’s possible to create and run strings of Python code from a C program by calling functions in the Python runtime API (a set of services exported by the libraries created when Python is compiled on your machine): #include <Python.h> ... Other Launch Options | 81
- 134. Py_Initialize(); // This is C, not Python PyRun_SimpleString("x = 'brave ' + 'sir robin'"); // But it runs Python code In this C code snippet, a program coded in the C language embeds the Python inter- preter by linking in its libraries, and passes it a Python assignment statement string to run. C programs may also gain access to Python modules and objects and process or execute them using other Python API tools. This book isn’t about Python/C integration, but you should be aware that, depending on how your organization plans to use Python, you may or may not be the one who actually starts the Python programs you create. Regardless, you can usually still use the interactive and file-based launching techniques described here to test code in isolation from those enclosing systems that may eventually use it.6 Frozen Binary Executables Frozen binary executables, described in Chapter 2, are packages that combine your program’s byte code and the Python interpreter into a single executable program. This approach enables Python programs to be launched in the same ways that you would launch any other executable program (icon clicks, command lines, etc.). While this option works well for delivery of products, it is not really intended for use during pro- gram development; you normally freeze just before shipping (after development is fin- ished). See the prior chapter for more on this option. Text Editor Launch Options As mentioned previously, although they’re not full-blown IDE GUIs, most program- mer-friendly text editors have support for editing, and possibly running, Python pro- grams. Such support may be built in or fetchable on the Web. For instance, if you are familiar with the Emacs text editor, you can do all your Python editing and launching from inside that text editor. See the text editor resources page at http://www.python .org/editors for more details, or search the Web for the phrase “Python editors.” Still Other Launch Options Depending on your platform, there may be additional ways that you can start Python programs. For instance, on some Macintosh systems you may be able to drag Python program file icons onto the Python interpreter icon to make them execute, and on some Windows systems you can always start Python scripts with the Run... option in the Start menu. Additionally, the Python standard library has utilities that allow Python programs to be started by other Python programs in separate processes (e.g., os.popen, 6. See Programming Python (O’Reilly) for more details on embedding Python in C/C++. The embedding API can call Python functions directly, load modules, and more. Also, note that the Jython system allows Java programs to invoke Python code using a Java-based API (a Python interpreter class). 82 | Chapter 3: How You Run Programs
- 135. os.system), and Python scripts might also be spawned in larger contexts like the Web (for instance, a web page might invoke a script on a server); however, these are beyond the scope of the present chapter. Future Possibilities? This chapter reflects current practice, but much of the material is both platform- and time-specific. Indeed, many of the execution and launch details presented arose during the shelf life of this book’s various editions. As with program execution options, it’s not impossible that new program launch options may arise over time. New operating systems, and new versions of existing systems, may also provide exe- cution techniques beyond those outlined here. In general, because Python keeps pace with such changes, you should be able to launch Python programs in whatever way makes sense for the machines you use, both now and in the future—be that by swiping on tablet PCs and smartphones, grabbing icons in a virtual reality, or shouting a script’s name over your coworkers’ conversations. Implementation changes may also impact launch schemes somewhat (e.g., a full com- piler could produce normal executables that are launched much like frozen binaries today). If I knew what the future truly held, though, I would probably be talking to a stockbroker instead of writing these words! Which Option Should I Use? With all these options, true beginners might naturally ask: which one is best for me? In general, you should give the IDLE interface a try if you are just getting started with Python. It provides a user-friendly GUI environment and hides some of the underlying configuration details. It also comes with a platform-neutral text editor for coding your scripts, and it’s a standard and free part of the Python system. If, on the other hand, you are an experienced programmer, you might be more com- fortable with simply the text editor of your choice in one window, and another window for launching the programs you edit via system command lines and icon clicks (in fact, this is how I develop Python programs, but I have a Unix-biased distant past). Because the choice of development environments is very subjective, I can’t offer much more in the way of universal guidelines. In general, whatever environment you like to use will be the best for you to use. Debugging Python Code Naturally, none of my readers or students ever have bugs in their code (insert smiley here), but for less fortunate friends of yours who may, here’s a quick review of the strategies commonly used by real-world Python programmers to debug code, for you to refer to as you start coding in earnest: Which Option Should I Use? | 83
- 136. • Do nothing. By this, I don’t mean that Python programmers don’t debug their code—but when you make a mistake in a Python program, you get a very useful and readable error message (you’ll get to see some soon, if you haven’t already). If you already know Python, and especially for your own code, this is often enough —read the error message, and go fix the tagged line and file. For many, this is debugging in Python. It may not always be ideal for larger systems you didn’t write, though. • Insert print statements. Probably the main way that Python programmers debug their code (and the way that I debug Python code) is to insert print statements and run again. Because Python runs immediately after changes, this is usually the quickest way to get more information than error messages provide. The print statements don’t have to be sophisticated—a simple “I am here” or display of variable values is usually enough to provide the context you need. Just remember to delete or comment out (i.e., add a # before) the debugging prints before you ship your code! • Use IDE GUI debuggers. For larger systems you didn’t write, and for beginners who want to trace code in more detail, most Python development GUIs have some sort of point-and-click debugging support. IDLE has a debugger too, but it doesn’t appear to be used very often in practice—perhaps because it has no command line, or perhaps because adding print statements is usually quicker than setting up a GUI debugging session. To learn more, see IDLE’s Help, or simply try it on your own; its basic interface is described in the section “Advanced IDLE Tools” on page 77. Other IDEs, such as Eclipse, NetBeans, Komodo, and Wing IDE, offer advanced point-and-click debuggers as well; see their documentation if you use them. • Use the pdb command-line debugger. For ultimate control, Python comes with a source code debugger named pdb, available as a module in Python’s standard library. In pdb, you type commands to step line by line, display variables, set and clear breakpoints, continue to a breakpoint or error, and so on. You can launch pdb interactively by importing it, or as a top-level script. Either way, because you can type commands to control the session, it provides a powerful debugging tool. pdb also includes a postmortem function (pdb.pm()) that you can run after an exception occurs, to get information from the time of the error. See the Python library manual and Chapter 36 for more details on pdb, and Appendix A for an example or running pdb as a script with Python’s –m command argument. • Use Python’s –i command-line argument. Short of adding prints or running under pdb, you can still see what went wrong on errors. If you run your script from a command line and pass a -i argument between python and the name of your script (e.g., python –i m.py), Python will enter into its interactive interpreter mode (the >>> prompt) when your script exits, whether it ends successfully or runs into an error. At this point, you can print the final values of variables to get more details about what happened in your code because they are in the top-level namespace. You can also then import and run the pdb debugger for even more context; its postmortem mode will let you inspect the latest error if your script failed. Appen- dix A also shows -i in action. 84 | Chapter 3: How You Run Programs
- 137. • Otheroptions.Formorespecificdebuggingrequirements,youcanfindadditional tools in the open source domain, including support for multithreaded programs, embedded code, and process attachment. The Winpdb system, for example, is a standalone debugger with advanced debugging support and cross-platform GUI and console interfaces. These options will become more important as we start writing larger scripts. Probably the best news on the debugging front, though, is that errors are detected and reported in Python, rather than passing silently or crashing the system altogether. In fact, errors themselves are a well-defined mechanism known as exceptions, which you can catch and process (more on exceptions in Part VII). Making mistakes is never fun, of course, but take it from someone who recalls when debugging meant getting out a hex calcu- lator and poring over piles of memory dump printouts: Python’s debugging support makes errors much less painful than they might otherwise be. Chapter Summary In this chapter, we’ve looked at common ways to launch Python programs: by running code typed interactively, and by running code stored in files with system command lines, file icon clicks, module imports, exec calls, and IDE GUIs such as IDLE. We’ve covered a lot of pragmatic startup territory here. This chapter’s goal was to equip you with enough information to enable you to start writing some code, which you’ll do in the next part of the book. There, we will start exploring the Python language itself, beginning with its core data types—the objects that are the subjects of your programs. First, though, take the usual chapter quiz to exercise what you’ve learned here. Because this is the last chapter in this part of the book, it’s followed with a set of more complete exercises that test your mastery of this entire part’s topics. For help with the latter set of problems, or just for a refresher, be sure to turn to Appendix D after you’ve given the exercises a try. Test Your Knowledge: Quiz 1. How can you start an interactive interpreter session? 2. Where do you type a system command line to launch a script file? 3. Name four or more ways to run the code saved in a script file. 4. Name two pitfalls related to clicking file icons on Windows. 5. Why might you need to reload a module? 6. How do you run a script from within IDLE? 7. Name two pitfalls related to using IDLE. 8. What is a namespace, and how does it relate to module files? Test Your Knowledge: Quiz | 85
- 138. Test Your Knowledge: Answers 1. You can start an interactive session on Windows 7 and earlier by clicking your Start button, picking the All Programs option, clicking the Python entry, and selecting the “Python (command line)” menu option. You can also achieve the same effect on Windows and other platforms by typing python as a system command line in your system’s console window (a Command Prompt window on Windows). An- otheralternativeistolaunchIDLE,asitsmainPythonshellwindowisaninteractive session. Depending on your platform and Python, if you have not set your system’s PATH variable to find Python, you may need to cd to where Python is installed, or type its full directory path instead of just python (e.g., C:Python33python on Win- dows, unless you’re using the 3.3 launcher). 2. You type system command lines in whatever your platform provides as a system console: a Command Prompt window on Windows; an xterm or terminal window on Unix, Linux, and Mac OS X; and so on. You type this at the system’s prompt, not at the Python interactive interpreter’s “>>>” prompt—be careful not to con- fuse these prompts. 3. Code in a script (really, module) file can be run with system command lines, file icon clicks, imports and reloads, the exec built-in function, and IDE GUI selections such as IDLE’s Run→Run Module menu option. On Unix, they can also be run as executables with the #! trick, and some platforms support more specialized launch- ing techniques (e.g., drag and drop). In addition, some text editors have unique ways to run Python code, some Python programs are provided as standalone “fro- zen binary” executables, and some systems use Python code in embedded mode, where it is run automatically by an enclosing program written in a language like C, C++, or Java. The latter technique is usually done to provide a user customi- zation layer. 4. Scripts that print and then exit cause the output file to disappear immediately, before you can view the output (which is why the input trick comes in handy); error messages generated by your script also appear in an output window that closes before you can examine its contents (which is one reason that system com- mand lines and IDEs such as IDLE are better for most development). 5. Python imports (loads) a module only once per process, by default, so if you’ve changed its source code and want to run the new version without stopping and restarting Python, you’ll have to reload it. You must import a module at least once before you can reload it. Running files of code from a system shell command line, via an icon click, or via an IDE such as IDLE generally makes this a nonissue, as those launch schemes usually run the current version of the source code file each time. 6. Within the text edit window of the file you wish to run, select the window’s Run→Run Module menu option. This runs the window’s source code as a top-level script file and displays its output back in the interactive Python shell window. 86 | Chapter 3: How You Run Programs
- 139. 7. IDLE can still be hung by some types of programs—especially GUI programs that perform multithreading (an advanced technique beyond this book’s scope). Also, IDLE has some usability features that can burn you once you leave the IDLE GUI: a script’s variables are automatically imported to the interactive scope in IDLE and working directories are changed when you run a file, for instance, but Python itself does not take such steps in general. 8. A namespace is just a package of variables (i.e., names). It takes the form of an object with attributes in Python. Each module file is automatically a namespace— that is, a package of variables reflecting the assignments made at the top level of the file. Namespaces help avoid name collisions in Python programs: because each module file is a self-contained namespace, files must explicitly import other files in order to use their names. Test Your Knowledge: Part I Exercises It’s time to start doing a little coding on your own. This first exercise session is fairly simple, but it’s designed to make sure you’re ready to work along with the rest of the book, and a few of its questions hint at topics to come in later chapters. Be sure to check Part I in Appendix D for the answers; the exercises and their solutions sometimes con- tain supplemental information not discussed in the main text, so you should take a peek at the solutions even if you manage to answer all the questions on your own. 1. Interaction. Using a system command line, IDLE, or any other method that works on your platform, start the Python interactive command line (>>> prompt), and type the expression "Hello World!" (including the quotes). The string should be echoed back to you. The purpose of this exercise is to get your environment con- figured to run Python. In some scenarios, you may need to first run a cd shell command, type the full path to the Python executable, or add its path to your PATH environment variable. If desired, you can set PATH in your .cshrc or .kshrc file to make Python permanently available on Unix systems; on Windows, the envi- ronment variable GUI is usually what you want for this. See Appendix A for help with environment variable settings. 2. Programs. With the text editor of your choice, write a simple module file containing the single statement print('Hello module world!') and store it as module1.py. Now, run this file by using any launch option you like: running it in IDLE, clicking on its file icon, passing it to the Python interpreter on the system shell’s command line (e.g., python module1.py), built-in exec calls, imports and reloads, and so on. In fact, experiment by running your file with as many of the launch techniques discussed in this chapter as you can. Which technique seems easiest? (There is no right answer to this, of course.) 3. Modules. Start the Python interactive command line (>>> prompt) and import the module you wrote in exercise 2. Try moving the file to a different directory and importing it again from its original directory (i.e., run Python in the original di- Test Your Knowledge: Part I Exercises | 87
- 140. rectory when you import). What happens? (Hint: is there still a module1.pyc byte code file in the original directory, or something similar in a __pycache__ subdir- ectory there?) 4. Scripts. If your platform supports it, add the #! line to the top of your mod- ule1.py module file, give the file executable privileges, and run it directly as an executable. What does the first line need to contain? #! usually only has meaning on Unix, Linux, and Unix-like platforms such as Mac OS X; if you’re working on Windows, instead try running your file by listing just its name in a Command Promptwindowwithouttheword“python”beforeit(thisworksonrecentversions of Windows), via the Start→Run... dialog box, or similar. If you are using Python 3.3 or the Windows launcher that installs with it, experiment with changing your script’s #! line to launch different Python versions you may have installed on your computer (or equivalently, work through the tutorial in Appendix B). 5. Errors and debugging. Experiment with typing mathematical expressions and as- signments at the Python interactive command line. Along the way, type the ex- pressions 2 ** 500 and 1 / 0, and reference an undefined variable name as we did early on in this chapter. What happens? You may not know it yet, but when you make a mistake, you’re doing exception processing: a topic we’ll explore in depth in Part VII. As you’ll learn there, you are technically triggering what’s known as the default exception handler—logic that prints a standard error message. If you do not catch an error, the default handler does and prints the standard error message in response. Exceptions are also bound up with the notion of debugging in Python. When you’re first starting out, Python’s default error messages on exceptions will probably pro- vide as much error-handling support as you need—they give the cause of the error, as well as showing the lines in your code that were active when the error occurred. For more about debugging, see the sidebar “Debugging Python Code” on page 83. 6. Breaks and cycles. At the Python command line, type: L = [1, 2] # Make a 2-item list L.append(L) # Append L as a single item to itself L # Print L: a cyclic/circular object What happens? In all recent versions of Python, you’ll see a strange output that we’ll describe in the solutions appendix, and which will make more sense when we study references in the next part of the book. If you’re using a Python version older than 1.5.1, a Ctrl-C key combination will probably help on most platforms. Why do you think your version of Python responds the way it does for this code? If you do have a Python older than Release 1.5.1 (a hopefully rare scenario today!), make sure your machine can stop a program with a Ctrl-C key combination of some sort before running this test, or you may be waiting a long time. 88 | Chapter 3: How You Run Programs
- 141. 7. Documentation. Spend at least 15 minutes browsing the Python library and lan- guage manuals before moving on to get a feel for the available tools in the standard library and the structure of the documentation set. It takes at least this long to become familiar with the locations of major topics in the manual set; once you’ve done this, it’s easy to find what you need. You can find this manual via the Python Start button entry on some Windows, in the Python Docs option on the Help pull- down menu in IDLE, or online at http://www.python.org/doc. I’ll also have a few more words to say about the manuals and other documentation sources available (including PyDoc and the help function) in Chapter 15. If you still have time, go explore the Python website, as well as its PyPI third-party extension repository. Especially check out the Python.org (http://www.python.org) documentation and search pages; they can be crucial resources. Test Your Knowledge: Part I Exercises | 89
- 143. PART II Types and Operations
- 145. CHAPTER 4 Introducing Python Object Types This chapter begins our tour of the Python language. In an informal sense, in Python we do things with stuff.1 “Things” take the form of operations like addition and con- catenation, and “stuff” refers to the objects on which we perform those operations. In this part of the book, our focus is on that stuff, and the things our programs can do with it. Somewhat more formally, in Python, data takes the form of objects—either built-in objects that Python provides, or objects we create using Python classes or external language tools such as C extension libraries. Although we’ll firm up this definition later, objects are essentially just pieces of memory, with values and sets of associated oper- ations. As we’ll see, everything is an object in a Python script. Even simple numbers qualify, with values (e.g., 99), and supported operations (addition, subtraction, and so on). Because objects are also the most fundamental notion in Python programming, we’ll start this chapter with a survey of Python’s built-in object types. Later chapters provide a second pass that fills in details we’ll gloss over in this survey. Here, our goal is a brief tour to introduce the basics. The Python Conceptual Hierarchy Before we get to the code, let’s first establish a clear picture of how this chapter fits into the overall Python picture. From a more concrete perspective, Python programs can be decomposed into modules, statements, expressions, and objects, as follows: 1. Programs are composed of modules. 2. Modules contain statements. 3. Statements contain expressions. 4. Expressions create and process objects. 1. Pardon my formality. I’m a computer scientist. 93
- 146. The discussion of modules in Chapter 3 introduced the highest level of this hierarchy. This part’s chapters begin at the bottom—exploring both built-in objects and the ex- pressions you can code to use them. We’ll move on to study statements in the next part of the book, though we will find that they largely exist to manage the objects we’ll meet here. Moreover, by the time we reach classes in the OOP part of this book, we’ll discover that they allow us to define new object types of our own, by both using and emulating the object types we will explore here. Because of all this, built-in objects are a mandatory point of embarkation for all Python journeys. Traditional introductions to programming often stress its three pillars of sequence (“Do this, then that”), selection (“Do this if that is true”), and repetition (“Do this many times”). Python has tools in all three cat- egories, along with some for definition—of functions and classes. These themes may help you organize your thinking early on, but they are a bit artificial and simplistic. Expressions such as comprehensions, for ex- ample, are both repetition and selection; some of these terms have other meaningsinPython; and many laterconceptswon’tseemtofitthismold at all. In Python, the more strongly unifying principle is objects, and what we can do with them. To see why, read on. Why Use Built-in Types? If you’ve used lower-level languages such as C or C++, you know that much of your work centers on implementing objects—also known as data structures—to represent the components in your application’s domain. You need to lay out memory structures, manage memory allocation, implement search and access routines, and so on. These chores are about as tedious (and error-prone) as they sound, and they usually distract from your program’s real goals. In typical Python programs, most of this grunt work goes away. Because Python pro- vides powerful object types as an intrinsic part of the language, there’s usually no need to code object implementations before you start solving problems. In fact, unless you have a need for special processing that built-in types don’t provide, you’re almost al- ways better off using a built-in object instead of implementing your own. Here are some reasons why: • Built-in objects make programs easy to write. For simple tasks, built-in types are often all you need to represent the structure of problem domains. Because you get powerful tools such as collections (lists) and search tables (dictionaries) for free, you can use them immediately. You can get a lot of work done with Python’s built- in object types alone. • Built-in objects are components of extensions. For more complex tasks, you may need to provide your own objects using Python classes or C language inter- 94 | Chapter 4: Introducing Python Object Types
- 147. faces. But as you’ll see in later parts of this book, objects implemented manually are often built on top of built-in types such as lists and dictionaries. For instance, a stack data structure may be implemented as a class that manages or customizes a built-in list. • Built-in objects are often more efficient than custom data structures. Python’s built-in types employ already optimized data structure algorithms that are implemented in C for speed. Although you can write similar object types on your own, you’ll usually be hard-pressed to get the level of performance built-in object types provide. • Built-in objects are a standard part of the language. In some ways, Python borrows both from languages that rely on built-in tools (e.g., LISP) and languages that rely on the programmer to provide tool implementations or frameworks of their own (e.g., C++). Although you can implement unique object types in Python, you don’t need to do so just to get started. Moreover, because Python’s built-ins are standard, they’re always the same; proprietary frameworks, on the other hand, tend to differ from site to site. In other words, not only do built-in object types make programming easier, but they’re also more powerful and efficient than most of what can be created from scratch. Re- gardless of whether you implement new object types, built-in objects form the core of every Python program. Python’s Core Data Types Table 4-1 previews Python’s built-in object types and some of the syntax used to code their literals—that is, the expressions that generate these objects.2 Some of these types will probably seem familiar if you’ve used other languages; for instance, numbers and strings represent numeric and textual values, respectively, and file objects provide an interface for processing real files stored on your computer. To some readers, though, the object types in Table 4-1 may be more general and pow- erful than what you are accustomed to. For instance, you’ll find that lists and diction- aries alone are powerful data representation tools that obviate most of the work you do to support collections and searching in lower-level languages. In short, lists provide ordered collections of other objects, while dictionaries store objects by key; both lists and dictionaries may be nested, can grow and shrink on demand, and may contain objects of any type. 2. In this book, the term literal simply means an expression whose syntax generates an object—sometimes also called a constant. Note that the term “constant” does not imply objects or variables that can never be changed (i.e., this term is unrelated to C++’s const or Python’s “immutable”—a topic explored in the section “Immutability” on page 101). Python’s Core Data Types | 95
- 148. Table 4-1. Built-in objects preview Object type Example literals/creation Numbers 1234, 3.1415, 3+4j, 0b111, Decimal(), Fraction() Strings 'spam', "Bob's", b'ax01c', u'spxc4m' Lists [1, [2, 'three'], 4.5], list(range(10)) Dictionaries {'food': 'spam', 'taste': 'yum'}, dict(hours=10) Tuples (1, 'spam', 4, 'U'), tuple('spam'), namedtuple Files open('eggs.txt'), open(r'C:ham.bin', 'wb') Sets set('abc'), {'a', 'b', 'c'} Other core types Booleans, types, None Program unit types Functions, modules, classes (Part IV, Part V, Part VI) Implementation-related types Compiled code, stack tracebacks (Part IV, Part VII) AlsoshowninTable4-1,programunitssuchasfunctions,modules,andclasses—which we’ll meet in later parts of this book—are objects in Python too; they are created with statements and expressions such as def, class, import, and lambda and may be passed around scripts freely, stored within other objects, and so on. Python also provides a set of implementation-related types such as compiled code objects, which are generally of interest to tool builders more than application developers; we’ll explore these in later parts too, though in less depth due to their specialized roles. Despiteitstitle,Table4-1isn’treallycomplete,becauseeverythingweprocessinPython programs is a kind of object. For instance, when we perform text pattern matching in Python, we create pattern objects, and when we perform network scripting, we use socket objects. These other kinds of objects are generally created by importing and using functions in library modules—for example, in the re and socket modules for patterns and sockets—and have behavior all their own. We usually call the other object types in Table 4-1 core data types, though, because they are effectively built into the Python language—that is, there is specific expression syntax for generating most of them. For instance, when you run the following code with characters surrounded by quotes: >>> 'spam' you are, technically speaking, running a literal expression that generates and returns a new string object. There is specific Python language syntax to make this object. Simi- larly, an expression wrapped in square brackets makes a list, one in curly braces makes a dictionary, and so on. Even though, as we’ll see, there are no type declarations in Python, the syntax of the expressions you run determines the types of objects you create and use. In fact, object-generation expressions like those in Table 4-1 are generally where types originate in the Python language. 96 | Chapter 4: Introducing Python Object Types
- 149. Just as importantly, once you create an object, you bind its operation set for all time— you can perform only string operations on a string and list operations on a list. In formal terms, this means that Python is dynamically typed, a model that keeps track of types for you automatically instead of requiring declaration code, but it is also strongly ty- ped, a constraint that means you can perform on an object only operations that are valid for its type. We’ll study each of the object types in Table 4-1 in detail in upcoming chapters. Before digging into the details, though, let’s begin by taking a quick look at Python’s core objects in action. The rest of this chapter provides a preview of the operations we’ll explore in more depth in the chapters that follow. Don’t expect to find the full story here—the goal of this chapter is just to whet your appetite and introduce some key ideas. Still, the best way to get started is to get started, so let’s jump right into some real code. Numbers If you’ve done any programming or scripting in the past, some of the object types in Table 4-1 will probably seem familiar. Even if you haven’t, numbers are fairly straight- forward. Python’s core objects set includes the usual suspects: integers that have no fractional part, floating-point numbers that do, and more exotic types—complex num- bers with imaginary parts, decimals with fixed precision, rationals with numerator and denominator, and full-featured sets. Built-in numbers are enough to represent most numeric quantities—from your age to your bank balance—but more types are available as third-party add-ons. Although it offers some fancier options, Python’s basic number types are, well, basic. Numbers in Python support the normal mathematical operations. For instance, the plus sign (+) performs addition, a star (*) is used for multiplication, and two stars (**) are used for exponentiation: >>> 123 + 222 # Integer addition 345 >>> 1.5 * 4 # Floating-point multiplication 6.0 >>> 2 ** 100 # 2 to the power 100, again 1267650600228229401496703205376 Notice the last result here: Python 3.X’s integer type automatically provides extra pre- cision for large numbers like this when needed (in 2.X, a separate long integer type handles numbers too large for the normal integer type in similar ways). You can, for instance, compute 2 to the power 1,000,000 as an integer in Python, but you probably shouldn’t try to print the result—with more than 300,000 digits, you may be waiting awhile! >>> len(str(2 ** 1000000)) # How many digits in a really BIG number? 301030 Numbers | 97
- 150. This nested-call form works from inside out—first converting the ** result’s number to a string of digits with the built-in str function, and then getting the length of the resulting string with len. The end result is the number of digits. str and len work on many object types; more on both as we move along. On Pythons prior to 2.7 and 3.1, once you start experimenting with floating-point numbers, you’re likely to stumble across something that may look a bit odd at first glance: >>> 3.1415 * 2 # repr: as code (Pythons < 2.7 and 3.1) 6.2830000000000004 >>> print(3.1415 * 2) # str: user-friendly 6.283 The first result isn’t a bug; it’s a display issue. It turns out that there are two ways to print every object in Python—with full precision (as in the first result shown here), and inauser-friendlyform(asin thesecond).Formally,thefirstformisknownasanobject’s as-code repr, and the second is its user-friendly str. In older Pythons, the floating-point repr sometimes displays more precision than you might expect. The difference can also matter when we step up to using classes. For now, if something looks odd, try showing it with a print built-in function call statement. Better yet, upgrade to Python 2.7 and the latest 3.X, where floating-point numbers display themselves more intelligently, usually with fewer extraneous digits—since this book is based on Pythons 2.7 and 3.3, this is the display form I’ll be showing throughout this book for floating-point numbers: >>> 3.1415 * 2 # repr: as code (Pythons >= 2.7 and 3.1) 6.283 Besides expressions, there are a handful of useful numeric modules that ship with Python—modules are just packages of additional tools that we import to use: >>> import math >>> math.pi 3.141592653589793 >>> math.sqrt(85) 9.219544457292887 The math module contains more advanced numeric tools as functions, while the ran dom module performs random-number generation and random selections (here, from a Python list coded in square brackets—an ordered collection of other objects to be in- troduced later in this chapter): >>> import random >>> random.random() 0.7082048489415967 >>> random.choice([1, 2, 3, 4]) 1 Python also includes more exotic numeric objects—such as complex, fixed-precision, and rational numbers, as well as sets and Booleans—and the third-party open source 98 | Chapter 4: Introducing Python Object Types
- 151. extension domain has even more (e.g., matrixes and vectors, and extended precision numbers). We’ll defer discussion of these types until later in this chapter and book. So far, we’ve been using Python much like a simple calculator; to do better justice to its built-in types, let’s move on to explore strings. Strings Strings are used to record both textual information (your name, for instance) as well as arbitrary collections of bytes (such as an image file’s contents). They are our first example of what in Python we call a sequence—a positionally ordered collection of other objects. Sequences maintain a left-to-right order among the items they contain: their items are stored and fetched by their relative positions. Strictly speaking, strings are sequences of one-character strings; other, more general sequence types include lists and tuples, covered later. Sequence Operations As sequences, strings support operations that assume a positional ordering among items. For example, if we have a four-character string coded inside quotes (usually of the single variety), we can verify its length with the built-in len function and fetch its components with indexing expressions: >>> S = 'Spam' # Make a 4-character string, and assign it to a name >>> len(S) # Length 4 >>> S[0] # The first item in S, indexing by zero-based position 'S' >>> S[1] # The second item from the left 'p' In Python, indexes are coded as offsets from the front, and so start from 0: the first item is at index 0, the second is at index 1, and so on. Notice how we assign the string to a variable named S here. We’ll go into detail on how this works later (especially in Chapter 6), but Python variables never need to be declared ahead of time. A variable is created when you assign it a value, may be assigned any type of object, and is replaced with its value when it shows up in an expression. It must also have been previously assigned by the time you use its value. For the purposes of this chapter, it’s enough to know that we need to assign an object to a variable in order to save it for later use. In Python, we can also index backward, from the end—positive indexes count from the left, and negative indexes count back from the right: >>> S[-1] # The last item from the end in S 'm' >>> S[-2] # The second-to-last item from the end 'a' Strings | 99
- 152. Formally, a negative index is simply added to the string’s length, so the following two operations are equivalent (though the first is easier to code and less easy to get wrong): >>> S[-1] # The last item in S 'm' >>> S[len(S)-1] # Negative indexing, the hard way 'm' Notice that we can use an arbitrary expression in the square brackets, not just a hard- coded number literal—anywhere that Python expects a value, we can use a literal, a variable, or any expression we wish. Python’s syntax is completely general this way. In addition to simple positional indexing, sequences also support a more general form of indexing known as slicing, which is a way to extract an entire section (slice) in a single step. For example: >>> S # A 4-character string 'Spam' >>> S[1:3] # Slice of S from offsets 1 through 2 (not 3) 'pa' Probably the easiest way to think of slices is that they are a way to extract an entire column from a string in a single step. Their general form, X[I:J], means “give me ev- erything in X from offset I up to but not including offset J.” The result is returned in a new object. The second of the preceding operations, for instance, gives us all the char- acters in string S from offsets 1 through 2 (that is, 1 through 3 – 1) as a new string. The effect is to slice or “parse out” the two characters in the middle. In a slice, the left bound defaults to zero, and the right bound defaults to the length of the sequence being sliced. This leads to some common usage variations: >>> S[1:] # Everything past the first (1:len(S)) 'pam' >>> S # S itself hasn't changed 'Spam' >>> S[0:3] # Everything but the last 'Spa' >>> S[:3] # Same as S[0:3] 'Spa' >>> S[:-1] # Everything but the last again, but simpler (0:-1) 'Spa' >>> S[:] # All of S as a top-level copy (0:len(S)) 'Spam' Note in the second-to-last command how negative offsets can be used to give bounds for slices, too, and how the last operation effectively copies the entire string. As you’ll learn later, there is no reason to copy a string, but this form can be useful for sequences like lists. Finally, as sequences, strings also support concatenation with the plus sign (joining two strings into a new string) and repetition (making a new string by repeating another): >>> S 'Spam' 100 | Chapter 4: Introducing Python Object Types
- 153. >>> S + 'xyz' # Concatenation 'Spamxyz' >>> S # S is unchanged 'Spam' >>> S * 8 # Repetition 'SpamSpamSpamSpamSpamSpamSpamSpam' Notice that the plus sign (+) means different things for different objects: addition for numbers, and concatenation for strings. This is a general property of Python that we’ll call polymorphism later in the book—in sum, the meaning of an operation depends on the objects being operated on. As you’ll see when we study dynamic typing, this poly- morphismpropertyaccountsformuchoftheconcisenessandflexibilityofPythoncode. Because types aren’t constrained, a Python-coded operation can normally work on many different types of objects automatically, as long as they support a compatible interface (like the + operation here). This turns out to be a huge idea in Python; you’ll learn more about it later on our tour. Immutability Also notice in the prior examples that we were not changing the original string with any of the operations we ran on it. Every string operation is defined to produce a new string as its result, because strings are immutable in Python—they cannot be changed in place after they are created. In other words, you can never overwrite the values of immutable objects. For example, you can’t change a string by assigning to one of its positions, but you can always build a new one and assign it to the same name. Because Python cleans up old objects as you go (as you’ll see later), this isn’t as inefficient as it may sound: >>> S 'Spam' >>> S[0] = 'z' # Immutable objects cannot be changed ...error text omitted... TypeError: 'str' object does not support item assignment >>> S = 'z' + S[1:] # But we can run expressions to make new objects >>> S 'zpam' Every object in Python is classified as either immutable (unchangeable) or not. In terms of the core types, numbers, strings, and tuples are immutable; lists, dictionaries, and sets are not—they can be changed in place freely, as can most new objects you’ll code with classes. This distinction turns out to be crucial in Python work, in ways that we can’t yet fully explore. Among other things, immutability can be used to guarantee that an object remains constant throughout your program; mutable objects’ values can be changed at any time and place (and whether you expect it or not). Strings | 101
- 154. Strictly speaking, you can change text-based data in place if you either expand it into a list of individual characters and join it back together with nothing between, or use the newer bytearray type available in Pythons 2.6, 3.0, and later: >>> S = 'shrubbery' >>> L = list(S) # Expand to a list: [...] >>> L ['s', 'h', 'r', 'u', 'b', 'b', 'e', 'r', 'y'] >>> L[1] = 'c' # Change it in place >>> ''.join(L) # Join with empty delimiter 'scrubbery' >>> B = bytearray(b'spam') # A bytes/list hybrid (ahead) >>> B.extend(b'eggs') # 'b' needed in 3.X, not 2.X >>> B # B[i] = ord(c) works here too bytearray(b'spameggs') >>> B.decode() # Translate to normal string 'spameggs' The bytearray supports in-place changes for text, but only for text whose characters are all at most 8-bits wide (e.g., ASCII). All other strings are still immutable—bytear ray is a distinct hybrid of immutable bytes strings (whose b'...' syntax is required in 3.X and optional in 2.X) and mutable lists (coded and displayed in []), and we have to learn more about both these and Unicode text to fully grasp this code. Type-Specific Methods Every string operation we’ve studied so far is really a sequence operation—that is, these operations will work on other sequences in Python as well, including lists and tuples. In addition to generic sequence operations, though, strings also have operations all their own, available as methods—functions that are attached to and act upon a specific object, which are triggered with a call expression. For example, the string find method is the basic substring search operation (it returns the offset of the passed-in substring, or −1 if it is not present), and the string replace method performs global searches and replacements; both act on the subject that they are attached to and called from: >>> S = 'Spam' >>> S.find('pa') # Find the offset of a substring in S 1 >>> S 'Spam' >>> S.replace('pa', 'XYZ') # Replace occurrences of a string in S with another 'SXYZm' >>> S 'Spam' Again, despite the names of these string methods, we are not changing the original strings here, but creating new strings as the results—because strings are immutable, this is the only way this can work. String methods are the first line of text-processing 102 | Chapter 4: Introducing Python Object Types
- 155. tools in Python. Other methods split a string into substrings on a delimiter (handy as asimpleformofparsing),performcaseconversions,testthecontentofthestring(digits, letters, and so on), and strip whitespace characters off the ends of the string: >>> line = 'aaa,bbb,ccccc,dd' >>> line.split(',') # Split on a delimiter into a list of substrings ['aaa', 'bbb', 'ccccc', 'dd'] >>> S = 'spam' >>> S.upper() # Upper- and lowercase conversions 'SPAM' >>> S.isalpha() # Content tests: isalpha, isdigit, etc. True >>> line = 'aaa,bbb,ccccc,ddn' >>> line.rstrip() # Remove whitespace characters on the right side 'aaa,bbb,ccccc,dd' >>> line.rstrip().split(',') # Combine two operations ['aaa', 'bbb', 'ccccc', 'dd'] Notice the last command here—it strips before it splits because Python runs from left to right, making a temporary result along the way. Strings also support an advanced substitution operation known as formatting, available as both an expression (the orig- inal) and a string method call (new as of 2.6 and 3.0); the second of these allows you to omit relative argument value numbers as of 2.7 and 3.1: >>> '%s, eggs, and %s' % ('spam', 'SPAM!') # Formatting expression (all) 'spam, eggs, and SPAM!' >>> '{0}, eggs, and {1}'.format('spam', 'SPAM!') # Formatting method (2.6+, 3.0+) 'spam, eggs, and SPAM!' >>> '{}, eggs, and {}'.format('spam', 'SPAM!') # Numbers optional (2.7+, 3.1+) 'spam, eggs, and SPAM!' Formatting is rich with features, which we’ll postpone discussing until later in this book, and which tend to matter most when you must generate numeric reports: >>> '{:,.2f}'.format(296999.2567) # Separators, decimal digits '296,999.26' >>> '%.2f | %+05d' % (3.14159, −42) # Digits, padding, signs '3.14 | −0042' One note here: although sequence operations are generic, methods are not—although some types share some method names, string method operations generally work only on strings, and nothing else. As a rule of thumb, Python’s toolset is layered: generic operations that span multiple types show up as built-in functions or expressions (e.g., len(X), X[0]), but type-specific operations are method calls (e.g., aString.upper()). Finding the tools you need among all these categories will become more natural as you use Python more, but the next section gives a few tips you can use right now. Strings | 103
- 156. Getting Help The methods introduced in the prior section are a representative, but small, sample of what is available for string objects. In general, this book is not exhaustive in its look at object methods. For more details, you can always call the built-in dir function. This function lists variables assigned in the caller’s scope when called with no argument; more usefully, it returns a list of all the attributes available for any object passed to it. Because methods are function attributes, they will show up in this list. Assuming S is still the string, here are its attributes on Python 3.3 (Python 2.X varies slightly): >>> dir(S) ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] You probably won’t care about the names with double underscores in this list until later in the book, when we study operator overloading in classes—they represent the im- plementation of the string object and are available to support customization. The __add__ method of strings, for example, is what really performs concatenation; Python maps the first of the following to the second internally, though you shouldn’t usually use the second form yourself (it’s less intuitive, and might even run slower): >>> S + 'NI!' 'spamNI!' >>> S.__add__('NI!') 'spamNI!' In general, leading and trailing double underscores is the naming pattern Python uses for implementation details. The names without the underscores in this list are the call- able methods on string objects. The dir function simply gives the methods’ names. To ask what they do, you can pass them to the help function: >>> help(S.replace) Help on built-in function replace: replace(...) S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. 104 | Chapter 4: Introducing Python Object Types
- 157. help is one of a handful of interfaces to a system of code that ships with Python known as PyDoc—a tool for extracting documentation from objects. Later in the book, you’ll see thatPyDoccan alsorenderitsreportsinHTMLformat for displayonawebbrowser. You can also ask for help on an entire string (e.g., help(S)), but you may get more or less help than you want to see—information about every string method in older Py- thons,andprobablynohelpatallinnewerversionsbecausestringsaretreatedspecially. It’s generally better to ask about a specific method. Both dir and help also accept as arguments either a real object (like our string S), or the name of a data type (like str, list, and dict). The latter form returns the same list fordir butshowsfulltypedetailsforhelp,andallowsyoutoaskaboutaspecificmethod via type name (e.g., help on str.replace). For more details, you can also consult Python’s standard library reference manual or commercially published reference books, but dir and help are the first level of docu- mentation in Python. Other Ways to Code Strings So far, we’ve looked at the string object’s sequence operations and type-specific meth- ods. Python also provides a variety of ways for us to code strings, which we’ll explore in greater depth later. For instance, special characters can be represented as backslash escape sequences, which Python displays in xNN hexadecimal escape notation, unless they represent printable characters: >>> S = 'AnBtC' # n is end-of-line, t is tab >>> len(S) # Each stands for just one character 5 >>> ord('n') # n is a byte with the binary value 10 in ASCII 10 >>> S = 'A0B0C' # 0, a binary zero byte, does not terminate string >>> len(S) 5 >>> S # Non-printables are displayed as xNN hex escapes 'ax00Bx00C' Python allows strings to be enclosed in single or double quote characters—they mean the same thing but allow the other type of quote to be embedded with an escape (most programmers prefer single quotes). It also allows multiline string literals enclosed in triple quotes (single or double)—when this form is used, all the lines are concatenated together, and end-of-line characters are added where line breaks appear. This is a minor syntactic convenience, but it’s useful for embedding things like multiline HTML, XML, or JSON code in a Python script, and stubbing out lines of code temporarily—just add three quotes above and below: >>> msg = """ aaaaaaaaaaaaa Strings | 105
- 158. bbb'''bbbbbbbbbb""bbbbbbb'bbbb cccccccccccccc """ >>> msg 'naaaaaaaaaaaaanbbb'''bbbbbbbbbb""bbbbbbb'bbbbnccccccccccccccn' Python also supports a raw string literal that turns off the backslash escape mechanism. Such literals start with the letter r and are useful for strings like directory paths on Windows (e.g., r'C:textnew'). Unicode Strings Python’s strings also come with full Unicode support required for processing text in internationalized character sets. Characters in the Japanese and Russian alphabets, for example, are outside the ASCII set. Such non-ASCII text can show up in web pages, emails, GUIs, JSON, XML, or elsewhere. When it does, handling it well requires Uni- code support. Python has such support built in, but the form of its Unicode support varies per Python line, and is one of their most prominent differences. In Python 3.X, the normal str string handles Unicode text (including ASCII, which is just a simple kind of Unicode); a distinct bytes string type represents raw byte values (including media and encoded text); and 2.X Unicode literals are supported in 3.3 and later for 2.X compatibility (they are treated the same as normal 3.X str strings): >>> 'spxc4m' # 3.X: normal str strings are Unicode text 'spÄm' >>> b'ax01c' # bytes strings are byte-based data b'ax01c' >>> u'spu00c4m' # The 2.X Unicode literal works in 3.3+: just str 'spÄm' In Python 2.X, the normal str string handles both 8-bit character strings (including ASCII text) and raw byte values; a distinct unicode string type represents Unicode text; and 3.X bytes literals are supported in 2.6 and later for 3.X compatibility (they are treated the same as normal 2.X str strings): >>> print u'spxc4m' # 2.X: Unicode strings are a distinct type spÄm >>> 'ax01c' # Normal str strings contain byte-based text/data 'ax01c' >>> b'ax01c' # The 3.X bytes literal works in 2.6+: just str 'ax01c' Formally, in both 2.X and 3.X, non-Unicode strings are sequences of 8-bit bytes that print with ASCII characters when possible, and Unicode strings are sequences of Uni- code code points—identifying numbers for characters, which do not necessarily map to single bytes when encoded to files or stored in memory. In fact, the notion of bytes doesn’t apply to Unicode: some encodings include character code points too large for a byte, and even simple 7-bit ASCII text is not stored one byte per character under some encodings and memory storage schemes: 106 | Chapter 4: Introducing Python Object Types
- 159. >>> 'spam' # Characters may be 1, 2, or 4 bytes in memory 'spam' >>> 'spam'.encode('utf8') # Encoded to 4 bytes in UTF-8 in files b'spam' >>> 'spam'.encode('utf16') # But encoded to 10 bytes in UTF-16 b'xffxfesx00px00ax00mx00' Both 3.X and 2.X also support the bytearray string type we met earlier, which is es- sentially a bytes string (a str in 2.X) that supports most of the list object’s in-place mutable change operations. Both 3.X and 2.X also support coding non-ASCII characters with x hexadecimal and shortu andlongU Unicodeescapes,aswellasfile-wideencodingsdeclaredinprogram source files. Here’s our non-ASCII character coded three ways in 3.X (add a leading “u” and say “print” to see the same in 2.X): >>> 'spxc4u00c4U000000c4m' 'spÄÄÄm' What these values mean and how they are used differs between text strings, which are the normal string in 3.X and Unicode in 2.X, and byte strings, which are bytes in 3.X and the normal string in 2.X. All these escapes can be used to embed actual Unicode code-point ordinal-value integers in text strings. By contrast, byte strings use only x hexadecimal escapes to embed the encoded form of text, not its decoded code point values—encoded bytes are the same as code points, only for some encodings and char- acters: >>> 'u00A3', 'u00A3'.encode('latin1'), b'xA3'.decode('latin1') ('£', b'xa3', '£') As a notable difference, Python 2.X allows its normal and Unicode strings to be mixed in expressions as long as the normal string is all ASCII; in contrast, Python 3.X has a tighter model that never allows its normal and byte strings to mix without explicit conversion: u'x' + b'y' # Works in 2.X (where b is optional and ignored) u'x' + 'y' # Works in 2.X: u'xy' u'x' + b'y' # Fails in 3.3 (where u is optional and ignored) u'x' + 'y' # Works in 3.3: 'xy' 'x' + b'y'.decode() # Works in 3.X if decode bytes to str: 'xy' 'x'.encode() + b'y' # Works in 3.X if encode str to bytes: b'xy' Apart from these string types, Unicode processing mostly reduces to transferring text data to and from files—text is encoded to bytes when stored in a file, and decoded into characters (a.k.a. code points) when read back into memory. Once it is loaded, we usually process text as strings in decoded form only. Because of this model, though, files are also content-specific in 3.X:text files implement named encodings and accept and return str strings, but binary files instead deal in Strings | 107
- 160. bytes strings for raw binary data. In Python 2.X, normal files’ content is str bytes, and a special codecs module handles Unicode and represents content with the unicode type. We’ll meet Unicode again in the files coverage later in this chapter, but save the rest of the Unicode story for later in this book. It crops up briefly in a Chapter 25 example in conjunction with currency symbols, but for the most part is postponed until this book’s advanced topics part. Unicode is crucial in some domains, but many programmers can get by with just a passing acquaintance. If your data is all ASCII text, the string and file stories are largely the same in 2.X and 3.X. And if you’re new to programming, you can safely defer most Unicode details until you’ve mastered string basics. Pattern Matching One point worth noting before we move on is that none of the string object’s own methods support pattern-based text processing. Text pattern matching is an advanced tool outside this book’s scope, but readers with backgrounds in other scripting lan- guages may be interested to know that to do pattern matching in Python, we import a module called re. This module has analogous calls for searching, splitting, and re- placement, but because we can use patterns to specify substrings, we can be much more general: >>> import re >>> match = re.match('Hello[ t]*(.*)world', 'Hello Python world') >>> match.group(1) 'Python ' This example searches for a substring that begins with the word “Hello,” followed by zero or more tabs or spaces, followed by arbitrary characters to be saved as a matched group, terminated by the word “world.” If such a substring is found, portions of the substring matched by parts of the pattern enclosed in parentheses are available as groups.Thefollowingpattern,forexample,picksoutthreegroupsseparatedbyslashes, and is similar to splitting by an alternatives pattern: >>> match = re.match('[/:](.*)[/:](.*)[/:](.*)', '/usr/home:lumberjack') >>> match.groups() ('usr', 'home', 'lumberjack') >>> re.split('[/:]', '/usr/home/lumberjack') ['', 'usr', 'home', 'lumberjack'] Pattern matching is an advanced text-processing tool by itself, but there is also support in Python for even more advanced text and language processing, including XML and HTML parsing and natural language analysis. We’ll see additional brief examples of patterns and XML parsing at the end of Chapter 37, but I’ve already said enough about strings for this tutorial, so let’s move on to the next type. 108 | Chapter 4: Introducing Python Object Types
- 161. Lists The Python list object is the most general sequence provided by the language. Lists are positionally ordered collections of arbitrarily typed objects, and they have no fixed size. They are also mutable—unlike strings, lists can be modified in place by assignment to offsets as well as a variety of list method calls. Accordingly, they provide a very flexible tool for representing arbitrary collections—lists of files in a folder, employees in a company, emails in your inbox, and so on. Sequence Operations Because they are sequences, lists support all the sequence operations we discussed for strings; the only difference is that the results are usually lists instead of strings. For instance, given a three-item list: >>> L = [123, 'spam', 1.23] # A list of three different-type objects >>> len(L) # Number of items in the list 3 we can index, slice, and so on, just as for strings: >>> L[0] # Indexing by position 123 >>> L[:-1] # Slicing a list returns a new list [123, 'spam'] >>> L + [4, 5, 6] # Concat/repeat make new lists too [123, 'spam', 1.23, 4, 5, 6] >>> L * 2 [123, 'spam', 1.23, 123, 'spam', 1.23] >>> L # We're not changing the original list [123, 'spam', 1.23] Type-Specific Operations Python’s lists may be reminiscent of arrays in other languages, but they tend to be more powerful. For one thing, they have no fixed type constraint—the list we just looked at, for example, contains three objects of completely different types (an integer, a string, and a floating-point number). Further, lists have no fixed size. That is, they can grow and shrink on demand, in response to list-specific operations: >>> L.append('NI') # Growing: add object at end of list >>> L [123, 'spam', 1.23, 'NI'] >>> L.pop(2) # Shrinking: delete an item in the middle 1.23 >>> L # "del L[2]" deletes from a list too [123, 'spam', 'NI'] Lists | 109
- 162. Here, the list append method expands the list’s size and inserts an item at the end; the pop method (or an equivalent del statement) then removes an item at a given offset, causing the list to shrink. Other list methods insert an item at an arbitrary position (insert), remove a given item by value (remove), add multiple items at the end (extend), and so on. Because lists are mutable, most list methods also change the list object in place, instead of creating a new one: >>> M = ['bb', 'aa', 'cc'] >>> M.sort() >>> M ['aa', 'bb', 'cc'] >>> M.reverse() >>> M ['cc', 'bb', 'aa'] The list sort method here, for example, orders the list in ascending fashion by default, and reverse reverses it—in both cases, the methods modify the list directly. Bounds Checking Although lists have no fixed size, Python still doesn’t allow us to reference items that are not present. Indexing off the end of a list is always a mistake, but so is assigning off the end: >>> L [123, 'spam', 'NI'] >>> L[99] ...error text omitted... IndexError: list index out of range >>> L[99] = 1 ...error text omitted... IndexError: list assignment index out of range This is intentional, as it’s usually an error to try to assign off the end of a list (and a particularly nasty one in the C language, which doesn’t do as much error checking as Python). Rather than silently growing the list in response, Python reports an error. To grow a list, we call list methods such as append instead. Nesting One nice feature of Python’s core data types is that they support arbitrary nesting—we can nest them in any combination, and as deeply as we like. For example, we can have a list that contains a dictionary, which contains another list, and so on. One immediate application of this feature is to represent matrixes, or “multidimensional arrays” in Python. A list with nested lists will do the job for basic applications (you’ll get “...” continuation-line prompts on lines 2 and 3 of the following in some interfaces, but not in IDLE): 110 | Chapter 4: Introducing Python Object Types
- 163. >>> M = [[1, 2, 3], # A 3 × 3 matrix, as nested lists [4, 5, 6], # Code can span lines if bracketed [7, 8, 9]] >>> M [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Here, we’ve coded a list that contains three other lists. The effect is to represent a 3 × 3 matrix of numbers. Such a structure can be accessed in a variety of ways: >>> M[1] # Get row 2 [4, 5, 6] >>> M[1][2] # Get row 2, then get item 3 within the row 6 The first operation here fetches the entire second row, and the second grabs the third item within that row (it runs left to right, like the earlier string strip and split). Stringing together index operations takes us deeper and deeper into our nested-object structure.3 Comprehensions In addition to sequence operations and list methods, Python includes a more advanced operation known as a list comprehension expression, which turns out to be a powerful way to process structures like our matrix. Suppose, for instance, that we need to extract the second column of our sample matrix. It’s easy to grab rows by simple indexing because the matrix is stored by rows, but it’s almost as easy to get a column with a list comprehension: >>> col2 = [row[1] for row in M] # Collect the items in column 2 >>> col2 [2, 5, 8] >>> M # The matrix is unchanged [[1, 2, 3], [4, 5, 6], [7, 8, 9]] List comprehensions derive from set notation; they are a way to build a new list by running an expression on each item in a sequence, one at a time, from left to right. List comprehensions are coded in square brackets (to tip you off to the fact that they make a list) and are composed of an expression and a looping construct that share a variable name (row, here). The preceding list comprehension means basically what it says: “Give me row[1] for each row in matrix M, in a new list.” The result is a new list containing column 2 of the matrix. List comprehensions can be more complex in practice: 3. This matrix structure works for small-scale tasks, but for more serious number crunching you will probably want to use one of the numeric extensions to Python, such as the open source NumPy and SciPy systems. Such tools can store and process large matrixes much more efficiently than our nested list structure. NumPy has been said to turn Python into the equivalent of a free and more powerful version of the Matlab system, and organizations such as NASA, Los Alamos, JPL, and many others use this tool for scientific and financial tasks. Search the Web for more details. Lists | 111
- 164. >>> [row[1] + 1 for row in M] # Add 1 to each item in column 2 [3, 6, 9] >>> [row[1] for row in M if row[1] % 2 == 0] # Filter out odd items [2, 8] The first operation here, for instance, adds 1 to each item as it is collected, and the second uses an if clause to filter odd numbers out of the result using the % modulus expression (remainder of division). List comprehensions make new lists of results, but they can be used to iterate over any iterable object—a term we’ll flesh out later in this preview. Here, for instance, we use list comprehensions to step over a hardcoded list of coordinates and a string: >>> diag = [M[i][i] for i in [0, 1, 2]] # Collect a diagonal from matrix >>> diag [1, 5, 9] >>> doubles = [c * 2 for c in 'spam'] # Repeat characters in a string >>> doubles ['ss', 'pp', 'aa', 'mm'] These expressions can also be used to collect multiple values, as long as we wrap those values in a nested collection. The following illustrates using range—a built-in that gen- erates successive integers, and requires a surrounding list to display all its values in 3.X only (2.X makes a physical list all at once): >>> list(range(4)) # 0..3 (list() required in 3.X) [0, 1, 2, 3] >>> list(range(−6, 7, 2)) # −6 to +6 by 2 (need list() in 3.X) [−6, −4, −2, 0, 2, 4, 6] >>> [[x ** 2, x ** 3] for x in range(4)] # Multiple values, "if" filters [[0, 0], [1, 1], [4, 8], [9, 27]] >>> [[x, x / 2, x * 2] for x in range(−6, 7, 2) if x > 0] [[2, 1, 4], [4, 2, 8], [6, 3, 12]] As you can probably tell, list comprehensions, and relatives like the map and filter built-in functions, are too involved to cover more formally in this preview chapter. The main point of this brief introduction is to illustrate that Python includes both simple and advanced tools in its arsenal. List comprehensions are an optional feature, but they tend to be very useful in practice and often provide a substantial processing speed advantage. They also work on any type that is a sequence in Python, as well as some types that are not. You’ll hear much more about them later in this book. As a preview, though, you’ll find that in recent Pythons, comprehension syntax has been generalized for other roles: it’s not just for making lists today. For example, en- closing a comprehension in parentheses can also be used to create generators that pro- duce results on demand. To illustrate, the sum built-in sums items in a sequence—in this example, summing all items in our matrix’s rows on request: >>> G = (sum(row) for row in M) # Create a generator of row sums >>> next(G) # iter(G) not required here 112 | Chapter 4: Introducing Python Object Types
- 165. 6 >>> next(G) # Run the iteration protocol next() 15 >>> next(G) 24 The map built-in can do similar work, by generating the results of running items through a function, one at a time and on request. Like range, wrapping it in list forces it to return all its values in Python 3.X; this isn’t needed in 2.X where map makes a list of results all at once instead, and is not needed in other contexts that iterate automatically, unless multiple scans or list-like behavior is also required: >>> list(map(sum, M)) # Map sum over items in M [6, 15, 24] In Python 2.7 and 3.X, comprehension syntax can also be used to create sets and dictionaries: >>> {sum(row) for row in M} # Create a set of row sums {24, 6, 15} >>> {i : sum(M[i]) for i in range(3)} # Creates key/value table of row sums {0: 6, 1: 15, 2: 24} In fact, lists, sets, dictionaries, and generators can all be built with comprehensions in 3.X and 2.7: >>> [ord(x) for x in 'spaam'] # List of character ordinals [115, 112, 97, 97, 109] >>> {ord(x) for x in 'spaam'} # Sets remove duplicates {112, 97, 115, 109} >>> {x: ord(x) for x in 'spaam'} # Dictionary keys are unique {'p': 112, 'a': 97, 's': 115, 'm': 109} >>> (ord(x) for x in 'spaam') # Generator of values <generator object <genexpr> at 0x000000000254DAB0> To understand objects like generators, sets, and dictionaries, though, we must move ahead. Dictionaries Python dictionaries are something completely different (Monty Python reference in- tended)—they are not sequences at all, but are instead known as mappings. Mappings are also collections of other objects, but they store objects by key instead of by relative position. In fact, mappings don’t maintain any reliable left-to-right order; they simply map keys to associated values. Dictionaries, the only mapping type in Python’s core objects set, are also mutable: like lists, they may be changed in place and can grow and shrink on demand. Also like lists, they are a flexible tool for representing collections, but their more mnemonic keys are better suited when a collection’s items are named or labeled—fields of a database record, for example. Dictionaries | 113
- 166. Mapping Operations When written as literals, dictionaries are coded in curly braces and consist of a series of “key: value” pairs. Dictionaries are useful anytime we need to associate a set of values with keys—to describe the properties of something, for instance. As an example, con- sider the following three-item dictionary (with keys “food,” “quantity,” and “color,” perhaps the details of a hypothetical menu item?): >>> D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'} We can index this dictionary by key to fetch and change the keys’ associated values. The dictionary index operation uses the same syntax as that used for sequences, but the item in the square brackets is a key, not a relative position: >>> D['food'] # Fetch value of key 'food' 'Spam' >>> D['quantity'] += 1 # Add 1 to 'quantity' value >>> D {'color': 'pink', 'food': 'Spam', 'quantity': 5} Although the curly-braces literal form does see use, it is perhaps more common to see dictionaries built up in different ways (it’s rare to know all your program’s data before your program runs). The following code, for example, starts with an empty dictionary and fills it out one key at a time. Unlike out-of-bounds assignments in lists, which are forbidden, assignments to new dictionary keys create those keys: >>> D = {} >>> D['name'] = 'Bob' # Create keys by assignment >>> D['job'] = 'dev' >>> D['age'] = 40 >>> D {'age': 40, 'job': 'dev', 'name': 'Bob'} >>> print(D['name']) Bob Here, we’re effectively using dictionary keys as field names in a record that describes someone. In other applications, dictionaries can also be used to replace searching op- erations—indexing a dictionary by key is often the fastest way to code a search in Python. As we’ll learn later, we can also make dictionaries by passing to the dict type name either keyword arguments (a special name=value syntax in function calls), or the result of zipping together sequences of keys and values obtained at runtime (e.g., from files). Both the following make the same dictionary as the prior example and its equivalent {} literal form, though the first tends to make for less typing: >>> bob1 = dict(name='Bob', job='dev', age=40) # Keywords >>> bob1 {'age': 40, 'name': 'Bob', 'job': 'dev'} 114 | Chapter 4: Introducing Python Object Types
- 167. >>> bob2 = dict(zip(['name', 'job', 'age'], ['Bob', 'dev', 40])) # Zipping >>> bob2 {'job': 'dev', 'name': 'Bob', 'age': 40} Notice how the left-to-right order of dictionary keys is scrambled. Mappings are not positionally ordered, so unless you’re lucky, they’ll come back in a different order than you typed them. The exact order may vary per Python, but you shouldn’t depend on it, and shouldn’t expect yours to match that in this book. Nesting Revisited In the prior example, we used a dictionary to describe a hypothetical person, with three keys. Suppose, though, that the information is more complex. Perhaps we need to record a first name and a last name, along with multiple job titles. This leads to another application of Python’s object nesting in action. The following dictionary, coded all at once as a literal, captures more structured information: >>> rec = {'name': {'first': 'Bob', 'last': 'Smith'}, 'jobs': ['dev', 'mgr'], 'age': 40.5} Here, we again have a three-key dictionary at the top (keys “name,” “jobs,” and “age”), but the values have become more complex: a nested dictionary for the name to support multiple parts, and a nested list for the jobs to support multiple roles and future ex- pansion. We can access the components of this structure much as we did for our list- based matrix earlier, but this time most indexes are dictionary keys, not list offsets: >>> rec['name'] # 'name' is a nested dictionary {'last': 'Smith', 'first': 'Bob'} >>> rec['name']['last'] # Index the nested dictionary 'Smith' >>> rec['jobs'] # 'jobs' is a nested list ['dev', 'mgr'] >>> rec['jobs'][-1] # Index the nested list 'mgr' >>> rec['jobs'].append('janitor') # Expand Bob's job description in place >>> rec {'age': 40.5, 'jobs': ['dev', 'mgr', 'janitor'], 'name': {'last': 'Smith', 'first': 'Bob'}} Notice how the last operation here expands the nested jobs list—because the jobs list is a separate piece of memory from the dictionary that contains it, it can grow and shrink freely (object memory layout will be discussed further later in this book). The real reason for showing you this example is to demonstrate the flexibility of Python’s core data types. As you can see, nesting allows us to build up complex infor- mationstructuresdirectlyandeasily.Buildinga similarstructureinalow-levellanguage like C would be tedious and require much more code: we would have to lay out and Dictionaries | 115
- 168. declare structures and arrays, fill out values, link everything together, and so on. In Python, this is all automatic—running the expression creates the entire nested object structure for us. In fact, this is one of the main benefits of scripting languages like Python. Just as importantly, in a lower-level language we would have to be careful to clean up all of the object’s space when we no longer need it. In Python, when we lose the last reference to the object—by assigning its variable to something else, for example—all of the memory space occupied by that object’s structure is automatically cleaned up for us: >>> rec = 0 # Now the object's space is reclaimed Technically speaking, Python has a feature known as garbage collection that cleans up unused memory as your program runs and frees you from having to manage such details in your code. In standard Python (a.k.a. CPython), the space is reclaimed immediately, as soon as the last reference to an object is removed. We’ll study how this works later in Chapter 6; for now, it’s enough to know that you can use objects freely, without worrying about creating their space or cleaning up as you go. Also watch for a record structure similar to the one we just coded in Chapter 8, Chap- ter 9, and Chapter 27, where we’ll use it to compare and contrast lists, dictionaries, tuples, named tuples, and classes—an array of data structure options with tradeoffs we’ll cover in full later.4 Missing Keys: if Tests As mappings, dictionaries support accessing items by key only, with the sorts of oper- ations we’ve just seen. In addition, though, they also support type-specific operations with method calls that are useful in a variety of common use cases. For example, al- though we can assign to a new key to expand a dictionary, fetching a nonexistent key is still a mistake: >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D 4. Two application notes here. First, as a preview, the rec record we just created really could be an actual database record, when we employ Python’s object persistence system—an easy way to store native Python objects in simple files or access-by-key databases, which translates objects to and from serial byte streams automatically. We won’t go into details here, but watch for coverage of Python’s pickle and shelve persistence modules in Chapter 9, Chapter 28, Chapter 31, and Chapter 37, where we’ll explore them in the context of files, an OOP use case, classes, and 3.X changes, respectively. Second, if you are familiar with JSON (JavaScript Object Notation)—an emerging data-interchange format used for databases and network transfers—this example may also look curiously similar, though Python’s support for variables, arbitrary expressions, and changes can make its data structures more general. Python’s json library module supports creating and parsing JSON text, but the translation to Python objects is often trivial. Watch for a JSON example that uses this record in Chapter 9 when we study files. For a larger use case, see MongoDB, which stores data using a language-neutral binary-encoded serialization of JSON-like documents, and its PyMongo interface. 116 | Chapter 4: Introducing Python Object Types
- 169. {'a': 1, 'c': 3, 'b': 2} >>> D['e'] = 99 # Assigning new keys grows dictionaries >>> D {'a': 1, 'c': 3, 'b': 2, 'e': 99} >>> D['f'] # Referencing a nonexistent key is an error ...error text omitted... KeyError: 'f' This is what we want—it’s usually a programming error to fetch something that isn’t really there. But in some generic programs, we can’t always know what keys will be present when we write our code. How do we handle such cases and avoid errors? One solution is to test ahead of time. The dictionary in membership expression allows us to query the existence of a key and branch on the result with a Python if statement. In the following, be sure to press Enter twice to run the if interactively after typing its code (as explained in Chapter 3, an empty line means “go” at the interactive prompt), and just as for the earlier multiline dictionaries and lists, the prompt changes to “...” on some interfaces for lines two and beyond: >>> 'f' in D False >>> if not 'f' in D: # Python's sole selection statement print('missing') missing This book has more to say about the if statement in later chapters, but the form we’re using here is straightforward: it consists of the word if, followed by an expression that is interpreted as a true or false result, followed by a block of code to run if the test is true. In its full form, the if statement can also have an else clause for a default case, and one or more elif (“else if”) clauses for other tests. It’s the main selection statement tool in Python; along with both its ternary if/else expression cousin (which we’ll meet in a moment) and the if comprehension filter lookalike we saw earlier, it’s the way we code the logic of choices and decisions in our scripts. If you’ve used some other programming languages in the past, you might be wondering how Python knows when the if statement ends. I’ll explain Python’s syntax rules in depth in later chapters, but in short, if you have more than one action to run in a statement block, you simply indent all their statements the same way—this both pro- motes readable code and reduces the number of characters you have to type: >>> if not 'f' in D: print('missing') print('no, really...') # Statement blocks are indented missing no, really... Dictionaries | 117
- 170. Besides the in test, there are a variety of ways to avoid accessing nonexistent keys in the dictionaries we create: the get method, a conditional index with a default; the Python 2.X has_key method, an in work-alike that is no longer available in 3.X; the try statement, a tool we’ll first meet in Chapter 10 that catches and recovers from exceptions altogether; and the if/else ternary (three-part) expression, which is essen- tially an if statement squeezed onto a single line. Here are a few examples: >>> value = D.get('x', 0) # Index but with a default >>> value 0 >>> value = D['x'] if 'x' in D else 0 # if/else expression form >>> value 0 We’ll save the details on such alternatives until a later chapter. For now, let’s turn to another dictionary method’s role in a common use case. Sorting Keys: for Loops As mentioned earlier, because dictionaries are not sequences, they don’t maintain any dependable left-to-right order. If we make a dictionary and print it back, its keys may come back in a different order than that in which we typed them, and may vary per Python version and other variables: >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D {'a': 1, 'c': 3, 'b': 2} What do we do, though, if we do need to impose an ordering on a dictionary’s items? One common solution is to grab a list of keys with the dictionary keys method, sort that with the list sort method, and then step through the result with a Python for loop (as for if, be sure to press the Enter key twice after coding the following for loop, and omit the outer parenthesis in the print in Python 2.X): >>> Ks = list(D.keys()) # Unordered keys list >>> Ks # A list in 2.X, "view" in 3.X: use list() ['a', 'c', 'b'] >>> Ks.sort() # Sorted keys list >>> Ks ['a', 'b', 'c'] >>> for key in Ks: # Iterate though sorted keys print(key, '=>', D[key]) # <== press Enter twice here (3.X print) a => 1 b => 2 c => 3 This is a three-step process, although, as we’ll see in later chapters, in recent versions of Python it can be done in one step with the newer sorted built-in function. The 118 | Chapter 4: Introducing Python Object Types
- 171. sorted call returns the result and sorts a variety of object types, in this case sorting dictionary keys automatically: >>> D {'a': 1, 'c': 3, 'b': 2} >>> for key in sorted(D): print(key, '=>', D[key]) a => 1 b => 2 c => 3 Besides showcasing dictionaries, this use case serves to introduce the Python for loop. The for loop is a simple and efficient way to step through all the items in a sequence and run a block of code for each item in turn. A user-defined loop variable (key, here) is used to reference the current item each time through. The net effect in our example is to print the unordered dictionary’s keys and values, in sorted-key order. The for loop, and its more general colleague the while loop, are the main ways we code repetitive tasks as statements in our scripts. Really, though, the for loop, like its relative the list comprehension introduced earlier, is a sequence operation. It works on any object that is a sequence and, like the list comprehension, even on some things that are not. Here, for example, it is stepping across the characters in a string, printing the uppercase version of each as it goes: >>> for c in 'spam': print(c.upper()) S P A M Python’s while loop is a more general sort of looping tool; it’s not limited to stepping across sequences, but generally requires more code to do so: >>> x = 4 >>> while x > 0: print('spam!' * x) x -= 1 spam!spam!spam!spam! spam!spam!spam! spam!spam! spam! We’ll discuss looping statements, syntax, and tools in depth later in the book. First, though, I need to confess that this section has not been as forthcoming as it might have been. Really, the for loop, and all its cohorts that step through objects from left to right, are not just sequence operations, they are iterable operations—as the next section de- scribes. Dictionaries | 119
- 172. Iteration and Optimization If the last section’s for loop looks like the list comprehension expression introduced earlier, it should: both are really general iteration tools. In fact, both will work on any iterable object that follows the iteration protocol—pervasive ideas in Python that un- derlie all its iteration tools. In a nutshell, an object is iterable if it is either a physically stored sequence in memory, or an object that generates one item at a time in the context of an iteration operation —a sort of “virtual” sequence. More formally, both types of objects are considered iterable because they support the iteration protocol—they respond to the iter call with an object that advances in response to next calls and raises an exception when finished producing values. The generator comprehension expression we saw earlier is such an object: its values aren’t stored in memory all at once, but are produced as requested, usually by iteration tools. Python file objects similarly iterate line by line when used by an iteration tool: file content isn’t in a list, it’s fetched on demand. Both are iterable objects in Python— a category that expands in 3.X to include core tools like range and map. I’ll have more to say about the iteration protocol later in this book. For now, keep in mind that every Python tool that scans an object from left to right uses the iteration protocol. This is why the sorted call used in the prior section works on the dictionary directly—we don’t have to call the keys method to get a sequence because dictionaries are iterable objects, with a next that returns successive keys. It may also help you to see that any list comprehension expression, such as this one, which computes the squares of a list of numbers: >>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]] >>> squares [1, 4, 9, 16, 25] can always be coded as an equivalent for loop that builds the result list manually by appending as it goes: >>> squares = [] >>> for x in [1, 2, 3, 4, 5]: # This is what a list comprehension does squares.append(x ** 2) # Both run the iteration protocol internally >>> squares [1, 4, 9, 16, 25] Both tools leverage the iteration protocol internally and produce the same result. The list comprehension, though, and related functional programming tools like map and filter, will often run faster than a for loop today on some types of code (perhaps even twice as fast)—a property that could matter in your programs for large data sets. Having said that, though, I should point out that performance measures are tricky business in Python because it optimizes so much, and they may vary from release to release. 120 | Chapter 4: Introducing Python Object Types
- 173. A major rule of thumb in Python is to code for simplicity and readability first and worry about performance later, after your program is working, and after you’ve proved that there is a genuine performance concern. More often than not, your code will be quick enough as it is. If you do need to tweak code for performance, though, Python includes tools to help you out, including the time and timeit modules for timing the speed of alternatives, and the profile module for isolating bottlenecks. You’ll find more on these later in this book (see especially Chapter 21’s benchmarking case study) and in the Python manuals. For the sake of this preview, let’s move ahead to the next core data type. Tuples The tuple object (pronounced “toople” or “tuhple,” depending on whom you ask) is roughly like a list that cannot be changed—tuples are sequences, like lists, but they are immutable, like strings. Functionally, they’re used to represent fixed collections of items: the components of a specific calendar date, for instance. Syntactically, they are normally coded in parentheses instead of square brackets, and they support arbitrary types, arbitrary nesting, and the usual sequence operations: >>> T = (1, 2, 3, 4) # A 4-item tuple >>> len(T) # Length 4 >> T + (5, 6) # Concatenation (1, 2, 3, 4, 5, 6) >>> T[0] # Indexing, slicing, and more 1 Tuples also have type-specific callable methods as of Python 2.6 and 3.0, but not nearly as many as lists: >>> T.index(4) # Tuple methods: 4 appears at offset 3 3 >>> T.count(4) # 4 appears once 1 The primary distinction for tuples is that they cannot be changed once created. That is, they are immutable sequences (one-item tuples like the one here require a trailing comma): >>> T[0] = 2 # Tuples are immutable ...error text omitted... TypeError: 'tuple' object does not support item assignment >>> T = (2,) + T[1:] # Make a new tuple for a new value >>> T (2, 2, 3, 4) Tuples | 121
- 174. Like lists and dictionaries, tuples support mixed types and nesting, but they don’t grow and shrink because they are immutable (the parentheses enclosing a tuple’s items can usually be omitted, as done here): >>> T = 'spam', 3.0, [11, 22, 33] >>> T[1] 3.0 >>> T[2][1] 22 >>> T.append(4) AttributeError: 'tuple' object has no attribute 'append' Why Tuples? So, why have a type that is like a list, but supports fewer operations? Frankly, tuples are not generally used as often as lists in practice, but their immutability is the whole point. If you pass a collection of objects around your program as a list, it can be changed anywhere; if you use a tuple, it cannot. That is, tuples provide a sort of integrity con- straint that is convenient in programs larger than those we’ll write here. We’ll talk more about tuples later in the book, including an extension that builds upon them called named tuples. For now, though, let’s jump ahead to our last major core type: the file. Files File objects are Python code’s main interface to external files on your computer. They can be used to read and write text memos, audio clips, Excel documents, saved email messages, and whatever else you happen to have stored on your machine. Files are a core type, but they’re something of an oddball—there is no specific literal syntax for creating them. Rather, to create a file object, you call the built-in open function, passing in an external filename and an optional processing mode as strings. For example, to create a text output file, you would pass in its name and the 'w' pro- cessing mode string to write data: >>> f = open('data.txt', 'w') # Make a new file in output mode ('w' is write) >>> f.write('Hellon') # Write strings of characters to it 6 >>> f.write('worldn') # Return number of items written in Python 3.X 6 >>> f.close() # Close to flush output buffers to disk This creates a file in the current directory and writes text to it (the filename can be a full directory path if you need to access a file elsewhere on your computer). To read back what you just wrote, reopen the file in 'r' processing mode, for reading text input —this is the default if you omit the mode in the call. Then read the file’s content into a string, and display it. A file’s contents are always a string in your script, regardless of the type of data the file contains: 122 | Chapter 4: Introducing Python Object Types
- 175. >>> f = open('data.txt') # 'r' (read) is the default processing mode >>> text = f.read() # Read entire file into a string >>> text 'Hellonworldn' >>> print(text) # print interprets control characters Hello world >>> text.split() # File content is always a string ['Hello', 'world'] Other file object methods support additional features we don’t have time to cover here. For instance, file objects provide more ways of reading and writing (read accepts an optional maximum byte/character size, readline reads one line at a time, and so on), as well as other tools (seek moves to a new file position). As we’ll see later, though, the best way to read a file today is to not read it at all—files provide an iterator that auto- matically reads line by line in for loops and other contexts: >>> for line in open('data.txt'): print(line) We’ll meet the full set of file methods later in this book, but if you want a quick preview now, run a dir call on any open file and a help on any of the method names that come back: >>> dir(f) [ ...many names omitted... 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines'] >>>help(f.seek) ...try it and see... Binary Bytes Files The prior section’s examples illustrate file basics that suffice for many roles. Techni- cally, though, they rely on either the platform’s Unicode encoding default in Python 3.X, or the 8-bit byte nature of files in Python 2.X. Text files always encode strings in 3.X, and blindly write string content in 2.X. This is irrelevant for the simple ASCII data used previously, which maps to and from file bytes unchanged. But for richer types of data, file interfaces can vary depending on both content and the Python line you use. As hinted when we met strings earlier, Python 3.X draws a sharp distinction between text and binary data in files: text files represent content as normal str strings and per- form Unicode encoding and decoding automatically when writing and reading data, while binary files represent content as a special bytes string and allow you to access file content unaltered. Python 2.X supports the same dichotomy, but doesn’t impose it as rigidly, and its tools differ. Files | 123
- 176. For example, binary files are useful for processing media, accessing data created by C programs, and so on. To illustrate, Python’s struct module can both create and unpack packed binary data—raw bytes that record values that are not Python objects—to be written to a file in binary mode. We’ll study this technique in detail later in the book, but the concept is simple: the following creates a binary file in Python 3.X (binary files work the same in 2.X, but the “b” string literal prefix isn’t required and won’t be dis- played): >>> import struct >>> packed = struct.pack('>i4sh', 7, b'spam', 8) # Create packed binary data >>> packed # 10 bytes, not objects or text b'x00x00x00x07spamx00x08' >>> >>> file = open('data.bin', 'wb') # Open binary output file >>> file.write(packed) # Write packed binary data 10 >>> file.close() Reading binary data back is essentially symmetric; not all programs need to tread so deeply into the low-level realm of bytes, but binary files make this easy in Python: >>> data = open('data.bin', 'rb').read() # Open/read binary data file >>> data # 10 bytes, unaltered b'x00x00x00x07spamx00x08' >>> data[4:8] # Slice bytes in the middle b'spam' >>> list(data) # A sequence of 8-bit bytes [0, 0, 0, 7, 115, 112, 97, 109, 0, 8] >>> struct.unpack('>i4sh', data) # Unpack into objects again (7, b'spam', 8) Unicode Text Files Text files are used to process all sorts of text-based data, from memos to email content to JSON and XML documents. In today’s broader interconnected world, though, we can’t really talk about text without also asking “what kind?”—you must also know the text’s Unicode encoding type if either it differs from your platform’s default, or you can’t rely on that default for data portability reasons. Luckily, this is easier than it may sound. To access files containing non-ASCII Unicode text of the sort introduced earlier in this chapter, we simply pass in an encoding name if the text in the file doesn’t match the default encoding for our platform. In this mode, Python text files automatically encode on writes and decode on reads per the encoding scheme name you provide. In Python 3.X: >>> S = 'spxc4m' # Non-ASCII Unicode text >>> S 'spÄm' >>> S[2] # Sequence of characters 'Ä' >>> file = open('unidata.txt', 'w', encoding='utf-8') # Write/encode UTF-8 text 124 | Chapter 4: Introducing Python Object Types
- 177. >>> file.write(S) # 4 characters written 4 >>> file.close() >>> text = open('unidata.txt', encoding='utf-8').read() # Read/decode UTF-8 text >>> text 'spÄm' >>> len(text) # 4 chars (code points) 4 This automatic encoding and decoding is what you normally want. Because files handle this on transfers, you may process text in memory as a simple string of characters without concern for its Unicode-encoded origins. If needed, though, you can also see what’s truly stored in your file by stepping into binary mode: >>> raw = open('unidata.txt', 'rb').read() # Read raw encoded bytes >>> raw b'spxc3x84m' >>> len(raw) # Really 5 bytes in UTF-8 5 You can also encode and decode manually if you get Unicode data from a source other than a file—parsed from an email message or fetched over a network connection, for example: >>> text.encode('utf-8') # Manual encode to bytes b'spxc3x84m' >>> raw.decode('utf-8') # Manual decode to str 'spÄm' This is also useful to see how text files would automatically encode the same string differently under different encoding names, and provides a way to translate data to different encodings—it’s different bytes in files, but decodes to the same string in memory if you provide the proper encoding name: >>> text.encode('latin-1') # Bytes differ in others b'spxc4m' >>> text.encode('utf-16') b'xffxfesx00px00xc4x00mx00' >>> len(text.encode('latin-1')), len(text.encode('utf-16')) (4, 10) >>> b'xffxfesx00px00xc4x00mx00'.decode('utf-16') # But same string decoded 'spÄm' This all works more or less the same in Python 2.X, but Unicode strings are coded and displaywithaleading“u,”bytestringsdon’trequireorshowaleading“b,”andUnicode text files must be opened with codecs.open, which accepts an encoding name just like 3.X’s open, and uses the special unicode string to represent content in memory. Binary file mode may seem optional in 2.X since normal files are just byte-based data, but it’s required to avoid changing line ends if present (more on this later in the book): Files | 125
- 178. >>> import codecs >>> codecs.open('unidata.txt', encoding='utf8').read() # 2.X: read/decode text u'spxc4m' >>> open('unidata.txt', 'rb').read() # 2.X: read raw bytes 'spxc3x84m' >>> open('unidata.txt').read() # 2.X: raw/undecoded too 'spxc3x84m' Although you won’t generally need to care about this distinction if you deal only with ASCII text, Python’s strings and files are an asset if you deal with either binary data (which includes most types of media) or text in internationalized character sets (which includes most content on the Web and Internet at large today). Python also supports non-ASCII file names (not just content), but it’s largely automatic; tools such as walkers and listers offer more control when needed, though we’ll defer further details until Chapter 37. Other File-Like Tools The open function is the workhorse for most file processing you will do in Python. For more advanced tasks, though, Python comes with additional file-like tools: pipes, FIFOs, sockets, keyed-access files, persistent object shelves, descriptor-based files, re- lational and object-oriented database interfaces, and more. Descriptor files, for in- stance, support file locking and other low-level tools, and sockets provide an interface for networking and interprocess communication. We won’t cover many of these topics in this book, but you’ll find them useful once you start programming Python in earnest. Other Core Types Beyond the core types we’ve seen so far, there are others that may or may not qualify for membership in the category, depending on how broadly it is defined. Sets, for ex- ample, are a recent addition to the language that are neither mappings nor sequences; rather, they are unordered collections of unique and immutable objects. You create sets by calling the built-in set function or using new set literals and expressions in 3.X and 2.7, and they support the usual mathematical set operations (the choice of new {...} syntax for set literals makes sense, since sets are much like the keys of a valueless dic- tionary): >>> X = set('spam') # Make a set out of a sequence in 2.X and 3.X >>> Y = {'h', 'a', 'm'} # Make a set with set literals in 3.X and 2.7 >>> X, Y # A tuple of two sets without parentheses ({'m', 'a', 'p', 's'}, {'m', 'a', 'h'}) >>> X & Y # Intersection {'m', 'a'} >>> X | Y # Union {'m', 'h', 'a', 'p', 's'} >>> X - Y # Difference 126 | Chapter 4: Introducing Python Object Types
- 179. {'p', 's'} >>> X > Y # Superset False >>> {n ** 2 for n in [1, 2, 3, 4]} # Set comprehensions in 3.X and 2.7 {16, 1, 4, 9} Even less mathematically inclined programmers often find sets useful for common tasks such as filtering out duplicates, isolating differences, and performing order-neutral equality tests without sorting—in lists, strings, and all other iterable objects: >>> list(set([1, 2, 1, 3, 1])) # Filtering out duplicates (possibly reordered) [1, 2, 3] >>> set('spam') - set('ham') # Finding differences in collections {'p', 's'} >>> set('spam') == set('asmp') # Order-neutral equality tests (== is False) True Sets also support in membership tests, though all other collection types in Python do too: >>> 'p' in set('spam'), 'p' in 'spam', 'ham' in ['eggs', 'spam', 'ham'] (True, True, True) In addition, Python recently grew a few new numeric types: decimal numbers, which are fixed-precision floating-point numbers, and fraction numbers, which are rational numbers with both a numerator and a denominator. Both can be used to work around the limitations and inherent inaccuracies of floating-point math: >>> 1 / 3 # Floating-point (add a .0 in Python 2.X) 0.3333333333333333 >>> (2/3) + (1/2) 1.1666666666666665 >>> import decimal # Decimals: fixed precision >>> d = decimal.Decimal('3.141') >>> d + 1 Decimal('4.141') >>> decimal.getcontext().prec = 2 >>> decimal.Decimal('1.00') / decimal.Decimal('3.00') Decimal('0.33') >>> from fractions import Fraction # Fractions: numerator+denominator >>> f = Fraction(2, 3) >>> f + 1 Fraction(5, 3) >>> f + Fraction(1, 2) Fraction(7, 6) Python also comes with Booleans (with predefined True and False objects that are es- sentially just the integers 1 and 0 with custom display logic), and it has long supported a special placeholder object called None commonly used to initialize names and objects: Other Core Types | 127
- 180. >>> 1 > 2, 1 < 2 # Booleans (False, True) >>> bool('spam') # Object's Boolean value True >>> X = None # None placeholder >>> print(X) None >>> L = [None] * 100 # Initialize a list of 100 Nones >>> L [None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ...a list of 100 Nones...] How to Break Your Code’s Flexibility I’ll have more to say about all of Python’s object types later, but one merits special treatment here. The type object, returned by the type built-in function, is an object that gives the type of another object; its result differs slightly in 3.X, because types have merged with classes completely (something we’ll explore in the context of “new-style” classes in Part VI). Assuming L is still the list of the prior section: # In Python 2.X: >>> type(L) # Types: type of L is list type object <type 'list'> >>> type(type(L)) # Even types are objects <type 'type'> # In Python 3.X: >>> type(L) # 3.X: types are classes, and vice versa <class 'list'> >>> type(type(L)) # See Chapter 32 for more on class types <class 'type'> Besides allowing you to explore your objects interactively, the type object in its most practical application allows code to check the types of the objects it processes. In fact, there are at least three ways to do so in a Python script: >>> if type(L) == type([]): # Type testing, if you must... print('yes') yes >>> if type(L) == list: # Using the type name print('yes') yes >>> if isinstance(L, list): # Object-oriented tests print('yes') yes Now that I’ve shown you all these ways to do type testing, however, I am required by law to tell you that doing so is almost always the wrong thing to do in a Python program (and often a sign of an ex-C programmer first starting to use Python!). The reason why 128 | Chapter 4: Introducing Python Object Types
- 181. won’t become completely clear until later in the book, when we start writing larger code units such as functions, but it’s a (perhaps the) core Python concept. By checking for specific types in your code, you effectively break its flexibility—you limit it to working on just one type. Without such tests, your code may be able to work on a whole range of types. This is related to the idea of polymorphism mentioned earlier, and it stems from Python’s lack of type declarations. As you’ll learn, in Python, we code to object inter- faces (operations supported), not to types. That is, we care what an object does, not what it is. Not caring about specific types means that code is automatically applicable to many of them—any object with a compatible interface will work, regardless of its specific type. Although type checking is supported—and even required in some rare cases—you’ll see that it’s not usually the “Pythonic” way of thinking. In fact, you’ll find that polymorphism is probably the key idea behind using Python well. User-Defined Classes We’ll study object-oriented programming in Python—an optional but powerful feature of the language that cuts development time by supporting programming by customi- zation—in depth later in this book. In abstract terms, though, classes define new types of objects that extend the core set, so they merit a passing glance here. Say, for example, that you wish to have a type of object that models employees. Although there is no such specific core type in Python, the following user-defined class might fit the bill: >>> class Worker: def __init__(self, name, pay): # Initialize when created self.name = name # self is the new object self.pay = pay def lastName(self): return self.name.split()[-1] # Split string on blanks def giveRaise(self, percent): self.pay *= (1.0 + percent) # Update pay in place This class defines a new kind of object that will have name and pay attributes (sometimes called state information), as well as two bits of behavior coded as functions (normally called methods). Calling the class like a function generates instances of our new type, and the class’s methods automatically receive the instance being processed by a given method call (in the self argument): >>> bob = Worker('Bob Smith', 50000) # Make two instances >>> sue = Worker('Sue Jones', 60000) # Each has name and pay attrs >>> bob.lastName() # Call method: bob is self 'Smith' >>> sue.lastName() # sue is the self subject 'Jones' >>> sue.giveRaise(.10) # Updates sue's pay >>> sue.pay 66000.0 Other Core Types | 129
- 182. The implied “self” object is why we call this an object-oriented model: there is always an implied subject in functions within a class. In a sense, though, the class-based type simply builds on and uses core types—a user-defined Worker object here, for example, is just a collection of a string and a number (name and pay, respectively), plus functions for processing those two built-in objects. The larger story of classes is that their inheritance mechanism supports software hier- archies that lend themselves to customization by extension. We extend software by writing new classes, not by changing what already works. You should also know that classes are an optional feature of Python, and simpler built-in types such as lists and dictionaries are often better tools than user-coded classes. This is all well beyond the bounds of our introductory object-type tutorial, though, so consider this just a preview; for full disclosure on user-defined types coded with classes, you’ll have to read on. Because classes build upon other tools in Python, they are one of the major goals of this book’s journey. And Everything Else As mentioned earlier, everything you can process in a Python script is a type of object, so our object type tour is necessarily incomplete. However, even though everything in Python is an “object,” only those types of objects we’ve met so far are considered part of Python’s core type set. Other types in Python either are objects related to program execution (like functions, modules, classes, and compiled code), which we will study later, or are implemented by imported module functions, not language syntax. The latter of these also tend to have application-specific roles—text patterns, database in- terfaces, network connections, and so on. Moreover, keep in mind that the objects we’ve met here are objects, but not necessarily object-oriented—a concept that usually requires inheritance and the Python class statement, which we’ll meet again later in this book. Still, Python’s core objects are the workhorses of almost every Python script you’re likely to meet, and they usually are the basis of larger noncore types. Chapter Summary And that’s a wrap for our initial data type tour. This chapter has offered a brief intro- duction to Python’s core object types and the sorts of operations we can apply to them. We’ve studied generic operations that work on many object types (sequence operations such as indexing and slicing, for example), as well as type-specific operations available as method calls (for instance, string splits and list appends). We’ve also defined some key terms, such as immutability, sequences, and polymorphism. Along the way, we’ve seen that Python’s core object types are more flexible and pow- erful than what is available in lower-level languages such as C. For instance, Python’s lists and dictionaries obviate most of the work you do to support collections and 130 | Chapter 4: Introducing Python Object Types
- 183. searching in lower-level languages. Lists are ordered collections of other objects, and dictionaries are collections of other objects that are indexed by key instead of by posi- tion. Both dictionaries and lists may be nested, can grow and shrink on demand, and may contain objects of any type. Moreover, their space is automatically cleaned up as you go. We’ve also seen that strings and files work hand in hand to support a rich variety of binary and text data. I’ve skipped most of the details here in order to provide a quick tour, so you shouldn’t expect all of this chapter to have made sense yet. In the next few chapters we’ll start to dig deeper, taking a second pass over Python’s core object types that will fill in details omitted here, and give you a deeper understanding. We’ll start off the next chapter with an in-depth look at Python numbers. First, though, here is another quiz to review. Test Your Knowledge: Quiz We’ll explore the concepts introduced in this chapter in more detail in upcoming chapters, so we’ll just cover the big ideas here: 1. Name four of Python’s core data types. 2. Why are they called “core” data types? 3. What does “immutable” mean, and which three of Python’s core types are con- sidered immutable? 4. What does “sequence” mean, and which three types fall into that category? 5. What does “mapping” mean, and which core type is a mapping? 6. What is “polymorphism,” and why should you care? Test Your Knowledge: Answers 1. Numbers, strings, lists, dictionaries, tuples, files, and sets are generally considered to be the core object (data) types. Types, None, and Booleans are sometimes clas- sified this way as well. There are multiple number types (integer, floating point, complex, fraction, and decimal) and multiple string types (simple strings and Uni- code strings in Python 2.X, and text strings and byte strings in Python 3.X). 2. They are known as “core” types because they are part of the Python language itself and are always available; to create other objects, you generally must call functions in imported modules. Most of the core types have specific syntax for generating the objects: 'spam', for example, is an expression that makes a string and deter- mines the set of operations that can be applied to it. Because of this, core types are hardwiredintoPython’ssyntax.Incontrast,youmustcallthebuilt-inopen function to create a file object (even though this is usually considered a core type too). 3. An “immutable” object is an object that cannot be changed after it is created. Numbers, strings, and tuples in Python fall into this category. While you cannot Test Your Knowledge: Answers | 131
- 184. change an immutable object in place, you can always make a new one by running an expression. Bytearrays in recent Pythons offer mutability for text, but they are not normal strings, and only apply directly to text if it’s a simple 8-bit kind (e.g., ASCII). 4. A“sequence”isapositionallyorderedcollectionofobjects.Strings,lists,andtuples are all sequences in Python. They share common sequence operations, such as indexing, concatenation, and slicing, but also have type-specific method calls. A related term, “iterable,” means either a physical sequence, or a virtual one that produces its items on request. 5. The term “mapping” denotes an object that maps keys to associated values. Python’s dictionary is the only mapping type in the core type set. Mappings do not maintain any left-to-right positional ordering; they support access to data stored by key, plus type-specific method calls. 6. “Polymorphism” means that the meaning of an operation (like a +) depends on the objects being operated on. This turns out to be a key idea (perhaps the key idea) behind using Python well—not constraining code to specific types makes that code automatically applicable to many types. 132 | Chapter 4: Introducing Python Object Types
- 185. CHAPTER 5 Numeric Types This chapter begins our in-depth tour of the Python language. In Python, data takes the form of objects—either built-in objects that Python provides, or objects we create using Python tools and other languages such as C. In fact, objects are the basis of every Python program you will ever write. Because they are the most fundamental notion in Python programming, objects are also our first focus in this book. In the preceding chapter, we took a quick pass over Python’s core object types. Al- though essential terms were introduced in that chapter, we avoided covering too many specifics in the interest of space. Here, we’ll begin a more careful second look at data type concepts, to fill in details we glossed over earlier. Let’s get started by exploring our first data type category: Python’s numeric types and operations. Numeric Type Basics Most of Python’s number types are fairly typical and will probably seem familiar if you’ve used almost any other programming language in the past. They can be used to keep track of your bank balance, the distance to Mars, the number of visitors to your website, and just about any other numeric quantity. In Python, numbers are not really a single object type, but a category of similar types. Pythonsupportstheusualnumerictypes(integersandfloatingpoints),aswellasliterals for creating numbers and expressions for processing them. In addition, Python provides more advanced numeric programming support and objects for more advanced work. A complete inventory of Python’s numeric toolbox includes: • Integer and floating-point objects • Complex number objects • Decimal: fixed-precision objects • Fraction: rational number objects • Sets: collections with numeric operations 133
- 186. • Booleans: true and false • Built-in functions and modules: round, math, random, etc. • Expressions; unlimited integer precision; bitwise operations; hex, octal, and binary formats • Third-party extensions: vectors, libraries, visualization, plotting, etc. Because the types in this list’s first bullet item tend to see the most action in Python code, this chapter starts with basic numbers and fundamentals, then moves on to ex- plore the other types on this list, which serve specialized roles. We’ll also study sets here, which have both numeric and collection qualities, but are generally considered more the former than the latter. Before we jump into code, though, the next few sections get us started with a brief overview of how we write and process numbers in our scripts. Numeric Literals Among its basic types, Python provides integers, which are positive and negative whole numbers, and floating-point numbers, which are numbers with a fractional part (some- times called “floats” for verbal economy). Python also allows us to write integers using hexadecimal, octal, and binary literals; offers a complex number type; and allows in- tegers to have unlimited precision—they can grow to have as many digits as your mem- ory space allows. Table 5-1 shows what Python’s numeric types look like when written out in a program as literals or constructor function calls. Table 5-1. Numeric literals and constructors Literal Interpretation 1234, −24, 0, 99999999999999 Integers (unlimited size) 1.23, 1., 3.14e-10, 4E210, 4.0e+210 Floating-point numbers 0o177, 0x9ff, 0b101010 Octal, hex, and binary literals in 3.X 0177, 0o177, 0x9ff, 0b101010 Octal, octal, hex, and binary literals in 2.X 3+4j, 3.0+4.0j, 3J Complex number literals set('spam'), {1, 2, 3, 4} Sets: 2.X and 3.X construction forms Decimal('1.0'), Fraction(1, 3) Decimal and fraction extension types bool(X), True, False Boolean type and constants In general, Python’s numeric type literals are straightforward to write, but a few coding concepts are worth highlighting here: Integer and floating-point literals Integers are written as strings of decimal digits. Floating-point numbers have a decimal point and/or an optional signed exponent introduced by an e or E and followed by an optional sign. If you write a number with a decimal point or expo- nent, Python makes it a floating-point object and uses floating-point (not integer) 134 | Chapter 5: Numeric Types
- 187. math when the object is used in an expression. Floating-point numbers are imple- mented as C “doubles” in standard CPython, and therefore get as much precision as the C compiler used to build the Python interpreter gives to doubles. Integers in Python 2.X: normal and long In Python 2.X there are two integer types, normal (often 32 bits) and long (un- limited precision), and an integer may end in an l or L to force it to become a long integer. Because integers are automatically converted to long integers when their values overflow their allocated bits, you never need to type the letter L yourself— Python automatically converts up to long integer when extra precision is needed. Integers in Python 3.X: a single type In Python 3.X, the normal and long integer types have been merged—there is only integer, which automatically supports the unlimited precision of Python 2.X’s sep- arate long integer type. Because of this, integers can no longer be coded with a trailing l or L, and integers never print with this character either. Apart from this, most programs are unaffected by this change, unless they do type testing that checks for 2.X long integers. Hexadecimal, octal, and binary literals Integers may be coded in decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2), the last three of which are common in some programming do- mains. Hexadecimals start with a leading 0x or 0X, followed by a string of hexa- decimal digits (0–9 and A–F). Hex digits may be coded in lower- or uppercase. Octal literals start with a leading 0o or 0O (zero and lower- or uppercase letter o), followed by a string of digits (0–7). In 2.X, octal literals can also be coded with just a leading 0, but not in 3.X—this original octal form is too easily confused with decimal, and is replaced by the new 0o format, which can also be used in 2.X as of 2.6. Binary literals, new as of 2.6 and 3.0, begin with a leading 0b or 0B, followed by binary digits (0–1). Note that all of these literals produce integer objects in program code; they are just alternative syntaxes for specifying values. The built-in calls hex(I), oct(I), and bin(I) convert an integer to its representation string in these three bases, and int(str, base) converts a runtime string to an integer per a given base. Complex numbers Python complex literals are written as realpart+imaginarypart, where the imagi narypart is terminated with a j or J. The realpart is technically optional, so the imaginarypart may appear on its own. Internally, complex numbers are imple- mented as pairs of floating-point numbers, but all numeric operations perform complex math when applied to complex numbers. Complex numbers may also be created with the complex(real, imag) built-in call. Coding other numeric types As we’ll see later in this chapter, there are additional numeric types at the end of Table 5-1 that serve more advanced or specialized roles. You create some of these Numeric Type Basics | 135
- 188. by calling functions in imported modules (e.g., decimals and fractions), and others have literal syntax all their own (e.g., sets). Built-in Numeric Tools Besides the built-in number literals and construction calls shown in Table 5-1, Python provides a set of tools for processing number objects: Expression operators +, -, *, /, >>, **, &, etc. Built-in mathematical functions pow, abs, round, int, hex, bin, etc. Utility modules random, math, etc. We’ll meet all of these as we go along. Although numbers are primarily processed with expressions, built-ins, and modules, they also have a handful of type-specific methods today, which we’ll meet in this chapter as well. Floating-point numbers, for example, have an as_integer_ratio method that is useful for the fraction number type, and an is_integer method to test if the number is an integer. Integers have various attributes, including a new bit_length method in- troduced in Python 3.1 that gives the number of bits necessary to represent the object’s value. Moreover, as part collection and part number, sets also support both methods and expressions. Since expressions are the most essential tool for most number types, though, let’s turn to them next. Python Expression Operators Perhaps the most fundamental tool that processes numbers is the expression: a com- bination of numbers (or other objects) and operators that computes a value when ex- ecuted by Python. In Python, you write expressions using the usual mathematical no- tation and operator symbols. For instance, to add two numbers X and Y you would say X + Y, which tells Python to apply the + operator to the values named by X and Y. The result of the expression is the sum of X and Y, another number object. Table 5-2 lists all the operator expressions available in Python. Many are self-explana- tory; for instance, the usual mathematical operators (+, −, *, /, and so on) are supported. A few will be familiar if you’ve used other languages in the past: % computes a division remainder, << performs a bitwise left-shift, & computes a bitwise AND result, and so on. Others are more Python-specific, and not all are numeric in nature: for example, the is operator tests object identity (i.e., address in memory, a strict form of equality), and lambda creates unnamed functions. 136 | Chapter 5: Numeric Types
- 189. Table 5-2. Python expression operators and precedence Operators Description yield x Generator function send protocol lambda args: expression Anonymous function generation x if y else z Ternary selection (x is evaluated only if y is true) x or y Logical OR (y is evaluated only if x is false) x and y Logical AND (y is evaluated only if x is true) not x Logical negation x in y, x not in y Membership (iterables, sets) x is y, x is not y Object identity tests x < y, x <= y, x > y, x >= y x == y, x != y Magnitude comparison, set subset and superset; Value equality operators x | y Bitwise OR, set union x ^ y Bitwise XOR, set symmetric difference x & y Bitwise AND, set intersection x << y, x >> y Shift x left or right by y bits x + y x – y Addition, concatenation; Subtraction, set difference x * y x % y x / y, x // y Multiplication, repetition; Remainder, format; Division: true and floor −x, +x Negation, identity ˜x Bitwise NOT (inversion) x ** y Power (exponentiation) x[i] Indexing (sequence, mapping, others) x[i:j:k] Slicing x(...) Call (function, method, class, other callable) x.attr Attribute reference (...) Tuple, expression, generator expression [...] List, list comprehension {...} Dictionary, set, set and dictionary comprehensions Since this book addresses both Python 2.X and 3.X, here are some notes about version differences and recent additions related to the operators in Table 5-2: Numeric Type Basics | 137
- 190. • In Python 2.X, value inequality can be written as either X != Y or X <> Y. In Python 3.X, the latter of these options is removed because it is redundant. In either version, best practice is to use X != Y for all value inequality tests. • In Python 2.X, a backquotes expression`X` works the same asrepr(X) and converts objects to display strings. Due to its obscurity, this expression is removed in Python 3.X; use the more readable str and repr built-in functions, described in “Numeric Display Formats.” • The X // Y floor division expression always truncates fractional remainders in both Python 2.X and 3.X. The X / Y expression performs true division in 3.X (retaining remainders) and classic division in 2.X (truncating for integers). See “Division: Classic, Floor, and True” on page 146. • The syntax [...] is used for both list literals and list comprehension expressions. The latter of these performs an implied loop and collects expression results in a new list. See Chapter 4, Chapter 14, and Chapter 20 for examples. • The syntax (...) is used for tuples and expression grouping, as well as generator expressions—a form of list comprehension that produces results on demand, in- stead of building a result list. See Chapter 4 and Chapter 20 for examples. The parentheses may sometimes be omitted in all three contexts. • The syntax {...} is used for dictionary literals, and in Python 3.X and 2.7 for set literals and both dictionary and set comprehensions. See the set coverage in this chapter as well as Chapter 4, Chapter 8, Chapter 14, and Chapter 20 for examples. • The yield and ternary if/else selection expressions are available in Python 2.5 and later. The former returns send(...) arguments in generators; the latter is shorthand for a multiline if statement. yield requires parentheses if not alone on the right side of an assignment statement. • Comparison operators may be chained: X < Y < Z produces the same result as X < Y and Y < Z. See “Comparisons: Normal and Chained” on page 144 for details. • In recent Pythons, the slice expression X[I:J:K] is equivalent to indexing with a slice object: X[slice(I, J, K)]. • In Python 2.X, magnitude comparisons of mixed types are allowed, and convert numbers to a common type, and order other mixed types according to type names. In Python 3.X, nonnumeric mixed-type magnitude comparisons are not allowed and raise exceptions; this includes sorts by proxy. • Magnitude comparisons for dictionaries are also no longer supported in Python 3.X (though equality tests are); comparing sorted(aDict.items()) is one possible replacement. We’ll see most of the operators in Table 5-2 in action later; first, though, we need to take a quick look at the ways these operators may be combined in expressions. 138 | Chapter 5: Numeric Types
- 191. Mixed operators follow operator precedence As in most languages, in Python, you code more complex expressions by stringing together the operator expressions in Table 5-2. For instance, the sum of two multipli- cations might be written as a mix of variables and operators: A * B + C * D So, how does Python know which operation to perform first? The answer to this ques- tion lies in operator precedence. When you write an expression with more than one operator, Python groups its parts according to what are called precedence rules, and this grouping determines the order in which the expression’s parts are computed. Table 5-2 is ordered by operator precedence: • Operators lower in the table have higher precedence, and so bind more tightly in mixed expressions. • Operators in the same row in Table 5-2 generally group from left to right when combined (except for exponentiation, which groups right to left, and comparisons, which chain left to right). For example, if you write X + Y * Z, Python evaluates the multiplication first (Y * Z), then adds that result to X because * has higher precedence (is lower in the table) than +. Similarly, in this section’s original example, both multiplications (A * B and C * D) will happen before their results are added. Parentheses group subexpressions You can forget about precedence completely if you’re careful to group parts of expres- sions with parentheses. When you enclose subexpressions in parentheses, you override Python’s precedence rules; Python always evaluates expressions in parentheses first before using their results in the enclosing expressions. For instance, instead of coding X + Y * Z, you could write one of the following to force Python to evaluate the expression in the desired order: (X + Y) * Z X + (Y * Z) In the first case, + is applied to X and Y first, because this subexpression is wrapped in parentheses. In the second case, the * is performed first (just as if there were no paren- theses at all). Generally speaking, adding parentheses in large expressions is a good idea—it not only forces the evaluation order you want, but also aids readability. Mixed types are converted up Besides mixing operators in expressions, you can also mix numeric types. For instance, you can add an integer to a floating-point number: 40 + 3.14 Numeric Type Basics | 139
- 192. But this leads to another question: what type is the result—integer or floating point? The answer is simple, especially if you’ve used almost any other language before: in mixed-type numeric expressions, Python first converts operands up to the type of the most complicated operand, and then performs the math on same-type operands. This behavior is similar to type conversions in the C language. Python ranks the complexity of numeric types like so: integers are simpler than floating- point numbers, which are simpler than complex numbers. So, when an integer is mixed with a floating point, as in the preceding example, the integer is converted up to a floating-point value first, and floating-point math yields the floating-point result: >>> 40 + 3.14 # Integer to float, float math/result 43.14 Similarly, any mixed-type expression where one operand is a complex number results in the other operand being converted up to a complex number, and the expression yields a complex result. In Python 2.X, normal integers are also converted to long in- tegers whenever their values are too large to fit in a normal integer; in 3.X, integers subsume longs entirely. You can force the issue by calling built-in functions to convert types manually: >>> int(3.1415) # Truncates float to integer 3 >>> float(3) # Converts integer to float 3.0 However, you won’t usually need to do this: because Python automatically converts up to the more complex type within an expression, the results are normally what you want. Also, keep in mind that all these mixed-type conversions apply only when mixing numeric types (e.g., an integer and a floating point) in an expression, including those using numeric and comparison operators. In general, Python does not convert across any other type boundaries automatically. Adding a string to an integer, for example, results in an error, unless you manually convert one or the other; watch for an example when we meet strings in Chapter 7. In Python 2.X, nonnumeric mixed types can be compared, but no con- versions are performed—mixed types compare according to a rule that seems deterministic but not aesthetically pleasing: it compares the string names of the objects’ types. In 3.X, nonnumeric mixed-type magnitude comparisons are never allowed and raise exceptions. Note that this ap- plies to comparison operators such as > only; other operators like + do not allow mixed nonnumeric types in either 3.X or 2.X. 140 | Chapter 5: Numeric Types
- 193. Preview: Operator overloading and polymorphism Although we’re focusing on built-in numbers right now, all Python operators may be overloaded (i.e., implemented) by Python classes and C extension types to work on objects you create. For instance, you’ll see later that objects coded with classes may be added or concatenated with x+y expressions, indexed with x[i] expressions, and so on. Furthermore, Python itself automatically overloads some operators, such that they perform different actions depending on the type of built-in objects being processed. For example, the + operator performs addition when applied to numbers but performs concatenation when applied to sequence objects such as strings and lists. In fact, + can mean anything at all when applied to objects you define with classes. As we saw in the prior chapter, this property is usually called polymorphism—a term indicating that the meaning of an operation depends on the type of the objects being operated on. We’ll revisit this concept when we explore functions in Chapter 16, be- cause it becomes a much more obvious feature in that context. Numbers in Action On to the code! Probably the best way to understand numeric objects and expressions is to see them in action, so with those basics in hand let’s start up the interactive com- mand line and try some simple but illustrative operations (be sure to see Chapter 3 for pointers if you need help starting an interactive session). Variables and Basic Expressions First of all, let’s exercise some basic math. In the following interaction, we first assign two variables (a and b) to integers so we can use them later in a larger expression. Variables are simply names—created by you or Python—that are used to keep track of information in your program. We’ll say more about this in the next chapter, but in Python: • Variables are created when they are first assigned values. • Variables are replaced with their values when used in expressions. • Variables must be assigned before they can be used in expressions. • Variables refer to objects and are never declared ahead of time. In other words, these assignments cause the variables a and b to spring into existence automatically: % python >>> a = 3 # Name created: not declared ahead of time >>> b = 4 I’ve also used a comment here. Recall that in Python code, text after a # mark and continuing to the end of the line is considered to be a comment and is ignored by Numbers in Action | 141
- 194. Python. Comments are a way to write human-readable documentation for your code, and an important part of programming. I’ve added them to most of this book’s exam- ples to help explain the code. In the next part of the book, we’ll meet a related but more functional feature—documentation strings—that attaches the text of your comments to objects so it’s available after your code is loaded. Because code you type interactively is temporary, though, you won’t normally write comments in this context. If you’re working along, this means you don’t need to type any of the comment text from the # through to the end of the line; it’s not a required part of the statements we’re running this way. Now, let’s use our new integer objects in some expressions. At this point, the values of a and b are still 3 and 4, respectively. Variables like these are replaced with their values whenever they’re used inside an expression, and the expression results are echoed back immediately when we’re working interactively: >>> a + 1, a − 1 # Addition (3 + 1), subtraction (3 − 1) (4, 2) >>> b * 3, b / 2 # Multiplication (4 * 3), division (4 / 2) (12, 2.0) >>> a % 2, b ** 2 # Modulus (remainder), power (4 ** 2) (1, 16) >>> 2 + 4.0, 2.0 ** b # Mixed-type conversions (6.0, 16.0) Technically, the results being echoed back here are tuples of two values because the lines typed at the prompt contain two expressions separated by commas; that’s why the results are displayed in parentheses (more on tuples later). Note that the expressions work because the variables a and b within them have been assigned values. If you use a different variable that has not yet been assigned, Python reports an error rather than filling in some default value: >>> c * 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'c' is not defined You don’t need to predeclare variables in Python, but they must have been assigned at least once before you can use them. In practice, this means you have to initialize coun- ters to zero before you can add to them, initialize lists to an empty list before you can append to them, and so on. Here are two slightly larger expressions to illustrate operator grouping and more about conversions, and preview a difference in the division operator in Python 3.X and 2.X: >>> b / 2 + a # Same as ((4 / 2) + 3) [use 2.0 in 2.X] 5.0 >>> b / (2.0 + a) # Same as (4 / (2.0 + 3)) [use print before 2.7] 0.8 In the first expression, there are no parentheses, so Python automatically groups the components according to its precedence rules—because / is lower in Table 5-2 than 142 | Chapter 5: Numeric Types
- 195. +, it binds more tightly and so is evaluated first. The result is as if the expression had been organized with parentheses as shown in the comment to the right of the code. Also, notice that all the numbers are integers in the first expression. Because of that, Python 2.X’s / performs integer division and addition and will give a result of 5, whereas Python 3.X’s / performs true division, which always retains fractional remainders and gives the result 5.0 shown. If you want 2.X’s integer division in 3.X, code this as b // 2 + a; if you want 3.X’s true division in 2.X, code this as b / 2.0 + a (more on division in a moment). In the second expression, parentheses are added around the + part to force Python to evaluate it first (i.e., before the /). We also made one of the operands floating point by adding a decimal point: 2.0. Because of the mixed types, Python converts the integer referenced by a to a floating-point value (3.0) before performing the +. If instead all the numbers in this expression were integers, integer division (4 / 5) would yield the trun- cated integer 0 in Python 2.X but the floating point 0.8 shown in Python 3.X. Again, stay tuned for formal division details. Numeric Display Formats If you’re using Python 2.6, Python 3.0, or earlier, the result of the last of the preceding examples may look a bit odd the first time you see it: >>> b / (2.0 + a) # Pythons <= 2.6: echoes give more (or fewer) digits 0.80000000000000004 >>> print(b / (2.0 + a)) # But print rounds off digits 0.8 We met this phenomenon briefly in the prior chapter, and it’s not present in Pythons 2.7, 3.1, and later. The full story behind this odd result has to do with the limitations of floating-point hardware and its inability to exactly represent some values in a limited number of bits. Because computer architecture is well beyond this book’s scope, though, we’ll finesse this by saying that your computer’s floating-point hardware is doing the best it can, and neither it nor Python is in error here. In fact, this is really just a display issue—the interactive prompt’s automatic result echo shows more digits than the print statement here only because it uses a different algo- rithm. It’s the same number in memory. If you don’t want to see all the digits, use print; as this chapter’s sidebar “str and repr Display Formats” on page 144 will explain, you’ll get a user-friendly display. As of 2.7 and 3.1, Python’s floating-point display logic tries to be more intelligent, usually showing fewer decimal digits, but occasionally more. Note, however, that not all values have so many digits to display: >>> 1 / 2.0 0.5 Numbers in Action | 143
- 196. and that there are more ways to display the bits of a number inside your computer than using print and automatic echoes (the following are all run in Python 3.3, and may vary slightly in older versions): >>> num = 1 / 3.0 >>> num # Auto-echoes 0.3333333333333333 >>> print(num) # Print explicitly 0.3333333333333333 >>> '%e' % num # String formatting expression '3.333333e-01' >>> '%4.2f' % num # Alternative floating-point format '0.33' >>> '{0:4.2f}'.format(num) # String formatting method: Python 2.6, 3.0, and later '0.33' The last three of these expressions employ string formatting, a tool that allows for for- mat flexibility, which we will explore in the upcoming chapter on strings (Chapter 7). Its results are strings that are typically printed to displays or reports. str and repr Display Formats Technically, the difference between default interactive echoes and print corresponds to the difference between the built-in repr and str functions: >>> repr('spam') # Used by echoes: as-code form "'spam'" >>> str('spam') # Used by print: user-friendly form 'spam' Both of these convert arbitrary objects to their string representations: repr (and the default interactive echo) produces results that look as though they were code; str (and the print operation) converts to a typically more user-friendly format if available. Some objects have both—a str for general use, and a repr with extra details. This notion will resurface when we study both strings and operator overloading in classes, and you’ll find more on these built-ins in general later in the book. Besides providing print strings for arbitrary objects, the str built-in is also the name of the string data type, and in 3.X may be called with an encoding name to decode a Unicode string from a byte string (e.g., str(b'xy', 'utf8')), and serves as an alternative to the bytes.decode method we met in Chapter 4. We’ll study the latter advanced role in Chapter 37 of this book. Comparisons: Normal and Chained So far, we’ve been dealing with standard numeric operations (addition and multipli- cation), but numbers, like all Python objects, can also be compared. Normal compar- isons work for numbers exactly as you’d expect—they compare the relative magnitudes 144 | Chapter 5: Numeric Types
- 197. of their operands and return a Boolean result, which we would normally test and take action on in a larger statement and program: >>> 1 < 2 # Less than True >>> 2.0 >= 1 # Greater than or equal: mixed-type 1 converted to 1.0 True >>> 2.0 == 2.0 # Equal value True >>> 2.0 != 2.0 # Not equal value False Notice again how mixed types are allowed in numeric expressions (only); in the second test here, Python compares values in terms of the more complex type, float. Interestingly, Python also allows us to chain multiple comparisons together to perform range tests. Chained comparisons are a sort of shorthand for larger Boolean expres- sions. In short, Python lets us string together magnitude comparison tests to code chained comparisons such as range tests. The expression (A < B < C), for instance, tests whether B is between A and C; it is equivalent to the Boolean test (A < B and B < C) but is easier on the eyes (and the keyboard). For example, assume the following assignments: >>> X = 2 >>> Y = 4 >>> Z = 6 The following two expressions have identical effects, but the first is shorter to type, and it may run slightly faster since Python needs to evaluate Y only once: >>> X < Y < Z # Chained comparisons: range tests True >>> X < Y and Y < Z True The same equivalence holds for false results, and arbitrary chain lengths are allowed: >>> X < Y > Z False >>> X < Y and Y > Z False >>> 1 < 2 < 3.0 < 4 True >>> 1 > 2 > 3.0 > 4 False You can use other comparisons in chained tests, but the resulting expressions can be- come nonintuitive unless you evaluate them the way Python does. The following, for instance, is false just because 1 is not equal to 2: >>> 1 == 2 < 3 # Same as: 1 == 2 and 2 < 3 False # Not same as: False < 3 (which means 0 < 3, which is true!) Numbers in Action | 145
- 198. Python does not compare the 1 == 2 expression’s False result to 3—this would tech- nically mean the same as 0 < 3, which would be True (as we’ll see later in this chapter, True and False are just customized 1 and 0). One last note here before we move on: chaining aside, numeric comparisons are based on magnitudes, which are generally simple—though floating-point numbers may not always work as you’d expect, and may require conversions or other massaging to be compared meaningfully: >>> 1.1 + 2.2 == 3.3 # Shouldn't this be True?... False >>> 1.1 + 2.2 # Close to 3.3, but not exactly: limited precision 3.3000000000000003 >>> int(1.1 + 2.2) == int(3.3) # OK if convert: see also round, floor, trunc ahead True # Decimals and fractions (ahead) may help here too This stems from the fact that floating-point numbers cannot represent some values exactly due to their limited number of bits—a fundamental issue in numeric program- ming not unique to Python, which we’ll learn more about later when we meet deci- mals and fractions, tools that can address such limitations. First, though, let’s continue our tour of Python’s core numeric operations, with a deeper look at division. Division: Classic, Floor, and True You’ve seen how division works in the previous sections, so you should know that it behavesslightlydifferentlyinPython3.Xand2.X.Infact,thereareactuallythreeflavors of division, and two different division operators, one of which changes in 3.X. This story gets a bit detailed, but it’s another major change in 3.X and can break 2.X code, so let’s get the division operator facts straight: X / Y Classic and true division. In Python 2.X, this operator performs classic division, truncating results for integers, and keeping remainders (i.e., fractional parts) for floating-point numbers. In Python 3.X, it performs true division, always keeping remainders in floating-point results, regardless of types. X // Y Floor division. Added in Python 2.2 and available in both Python 2.X and 3.X, this operator always truncates fractional remainders down to their floor, regardless of types. Its result type depends on the types of its operands. Truedivisionwasaddedtoaddressthefactthattheresultsoftheoriginalclassicdivision model are dependent on operand types, and so can be difficult to anticipate in a dy- namically typed language like Python. Classic division was removed in 3.X because of thisconstraint—the/ and// operatorsimplementtrueandfloordivisionin3.X.Python 2.X defaults to classic and floor division, but you can enable true division as an option. In sum: 146 | Chapter 5: Numeric Types
- 199. • In3.X,the/ nowalwaysperformstruedivision,returningafloatresultthatincludes any remainder, regardless of operand types. The // performs floor division, which truncates the remainder and returns an integer for integer operands or a float if any operand is a float. • In 2.X, the / does classic division, performing truncating integer division if both operands are integers and float division (keeping remainders) otherwise. The // does floor division and works as it does in 3.X, performing truncating division for integers and floor division for floats. Here are the two operators at work in 3.X and 2.X—the first operation in each set is the crucial difference between the lines that may impact code: C:code> C:Python33python >>> >>> 10 / 4 # Differs in 3.X: keeps remainder 2.5 >>> 10 / 4.0 # Same in 3.X: keeps remainder 2.5 >>> 10 // 4 # Same in 3.X: truncates remainder 2 >>> 10 // 4.0 # Same in 3.X: truncates to floor 2.0 C:code> C:Python27python >>> >>> 10 / 4 # This might break on porting to 3.X! 2 >>> 10 / 4.0 2.5 >>> 10 // 4 # Use this in 2.X if truncation needed 2 >>> 10 // 4.0 2.0 Notice that the data type of the result for // is still dependent on the operand types in 3.X: if either is a float, the result is a float; otherwise, it is an integer. Although this may seem similar to the type-dependent behavior of / in 2.X that motivated its change in 3.X, the type of the return value is much less critical than differences in the return value itself. Moreover, because // was provided in part as a compatibility tool for programs that rely on truncating integer division (and this is more common than you might expect), it must return integers for integers. Using // instead of / in 2.X when integer truncation is required helps make code 3.X-compatible. Supporting either Python Although / behavior differs in 2.X and 3.X, you can still support both versions in your code. If your programs depend on truncating integer division, use // in both 2.X and 3.X as just mentioned. If your programs require floating-point results with remainders Numbers in Action | 147
- 200. for integers, use float to guarantee that one operand is a float around a / when run in 2.X: X = Y // Z # Always truncates, always an int result for ints in 2.X and 3.X X = Y / float(Z) # Guarantees float division with remainder in either 2.X or 3.X Alternatively, you can enable 3.X / division in 2.X with a __future__ import, rather than forcing it with float conversions: C:code> C:Python27python >>> from __future__ import division # Enable 3.X "/" behavior >>> 10 / 4 2.5 >>> 10 // 4 # Integer // is the same in both 2 This special from statement applies to the rest of your session when typed interactively like this, and must appear as the first executable line when used in a script file (and alas, we can import from the future in Python, but not the past; insert something about talking to “the Doc” here...). Floor versus truncation One subtlety: the // operator is informally called truncating division, but it’s more accurate to refer to it as floor division—it truncates the result down to its floor, which means the closest whole number below the true result. The net effect is to round down, not strictly truncate, and this matters for negatives. You can see the difference for yourself with the Python math module (modules must be imported before you can use their contents; more on this later): >>> import math >>> math.floor(2.5) # Closest number below value 2 >>> math.floor(-2.5) -3 >>> math.trunc(2.5) # Truncate fractional part (toward zero) 2 >>> math.trunc(-2.5) -2 When running division operators, you only really truncate for positive results, since truncation is the same as floor; for negatives, it’s a floor result (really, they are both floor, but floor is the same as truncation for positives). Here’s the case for 3.X: C:code> c:python33python >>> 5 / 2, 5 / −2 (2.5, −2.5) >>> 5 // 2, 5 // −2 # Truncates to floor: rounds to first lower integer (2, −3) # 2.5 becomes 2, −2.5 becomes −3 >>> 5 / 2.0, 5 / −2.0 (2.5, −2.5) 148 | Chapter 5: Numeric Types
- 201. >>> 5 // 2.0, 5 // −2.0 # Ditto for floats, though result is float too (2.0, −3.0) The 2.X case is similar, but / results differ again: C:code> c:python27python >>> 5 / 2, 5 / −2 # Differs in 3.X (2, −3) >>> 5 // 2, 5 // −2 # This and the rest are the same in 2.X and 3.X (2, −3) >>> 5 / 2.0, 5 / −2.0 (2.5, −2.5) >>> 5 // 2.0, 5 // −2.0 (2.0, −3.0) If you really want truncation toward zero regardless of sign, you can always run a float division result through math.trunc, regardless of Python version (also see the round built-in for related functionality, and the int built-in, which has the same effect here but requires no import): C:code> c:python33python >>> import math >>> 5 / −2 # Keep remainder −2.5 >>> 5 // −2 # Floor below result -3 >>> math.trunc(5 / −2) # Truncate instead of floor (same as int()) −2 C:code> c:python27python >>> import math >>> 5 / float(−2) # Remainder in 2.X −2.5 >>> 5 / −2, 5 // −2 # Floor in 2.X (−3, −3) >>> math.trunc(5 / float(−2)) # Truncate in 2.X −2 Why does truncation matter? As a wrap-up, if you are using 3.X, here is the short story on division operators for reference: >>> (5 / 2), (5 / 2.0), (5 / −2.0), (5 / −2) # 3.X true division (2.5, 2.5, −2.5, −2.5) >>> (5 // 2), (5 // 2.0), (5 // −2.0), (5 // −2) # 3.X floor division (2, 2.0, −3.0, −3) >>> (9 / 3), (9.0 / 3), (9 // 3), (9 // 3.0) # Both (3.0, 3.0, 3, 3.0) Numbers in Action | 149
- 202. For 2.X readers, division works as follows (the three bold outputs of integer division differ from 3.X): >>> (5 / 2), (5 / 2.0), (5 / −2.0), (5 / −2) # 2.X classic division (differs) (2, 2.5, −2.5, −3) >>> (5 // 2), (5 // 2.0), (5 // −2.0), (5 // −2) # 2.X floor division (same) (2, 2.0, −3.0, −3) >>> (9 / 3), (9.0 / 3), (9 // 3), (9 // 3.0) # Both (3, 3.0, 3, 3.0) It’s possible that the nontruncating behavior of / in 3.X may break a significant number of 2.X programs. Perhaps because of a C language legacy, many programmers rely on division truncation for integers and will have to learn to use // in such contexts instead. You should do so in all new 2.X and 3.X code you write today—in the former for 3.X compatibility, and in the latter because / does not truncate in 3.X. Watch for a simple prime number while loop example in Chapter 13, and a corresponding exercise at the end of Part IV that illustrates the sort of code that may be impacted by this / change. Alsostaytunedformoreonthespecialfrom commandusedinthissection;it’sdiscussed further in Chapter 25. Integer Precision Division may differ slightly across Python releases, but it’s still fairly standard. Here’s something a bit more exotic. As mentioned earlier, Python 3.X integers support un- limited size: >>> 999999999999999999999999999999 + 1 # 3.X 1000000000000000000000000000000 Python 2.X has a separate type for long integers, but it automatically converts any number too large to store in a normal integer to this type. Hence, you don’t need to code any special syntax to use longs, and the only way you can tell that you’re using 2.X longs is that they print with a trailing “L”: >>> 999999999999999999999999999999 + 1 # 2.X 1000000000000000000000000000000L Unlimited-precision integers are a convenient built-in tool. For instance, you can use them to count the U.S. national debt in pennies in Python directly (if you are so inclined, and have enough memory on your computer for this year’s budget). They are also why we were able to raise 2 to such large powers in the examples in Chapter 3. Here are the 3.X and 2.X cases: >>> 2 ** 200 1606938044258990275541962092341162602522202993782792835301376 >>> 2 ** 200 1606938044258990275541962092341162602522202993782792835301376L 150 | Chapter 5: Numeric Types
- 203. Because Python must do extra work to support their extended precision, integer math is usually substantially slower than normal when numbers grow large. However, if you need the precision, the fact that it’s built in for you to use will likely outweigh its performance penalty. Complex Numbers Although less commonly used than the types we’ve been exploring thus far, complex numbers are a distinct core object type in Python. They are typically used in engineering and science applications. If you know what they are, you know why they are useful; if not, consider this section optional reading. Complex numbers are represented as two floating-point numbers—the real and imag- inary parts—and you code them by adding a j or J suffix to the imaginary part. We can also write complex numbers with a nonzero real part by adding the two parts with a +. For example, the complex number with a real part of 2 and an imaginary part of −3 is written 2 + −3j. Here are some examples of complex math at work: >>> 1j * 1J (-1+0j) >>> 2 + 1j * 3 (2+3j) >>> (2 + 1j) * 3 (6+3j) Complex numbers also allow us to extract their parts as attributes, support all the usual mathematical expressions, and may be processed with tools in the standard cmath module (the complex version of the standard math module). Because complex numbers are rare in most programming domains, though, we’ll skip the rest of this story here. Check Python’s language reference manual for additional details. Hex, Octal, Binary: Literals and Conversions Python integers can be coded in hexadecimal, octal, and binary notation, in addition to the normal base-10 decimal coding we’ve been using so far. The first three of these may at first seem foreign to 10-fingered beings, but some programmers find them con- venient alternatives for specifying values, especially when their mapping to bytes and bits is important. The coding rules were introduced briefly at the start of this chapter; let’s look at some live examples here. Keep in mind that these literals are simply an alternative syntax for specifying the value of an integer object. For example, the following literals coded in Python 3.X or 2.X produce normal integers with the specified values in all three bases. In memory, an integer’s value is the same, regardless of the base we use to specify it: >>> 0o1, 0o20, 0o377 # Octal literals: base 8, digits 0-7 (3.X, 2.6+) (1, 16, 255) >>> 0x01, 0x10, 0xFF # Hex literals: base 16, digits 0-9/A-F (3.X, 2.X) Numbers in Action | 151
- 204. (1, 16, 255) >>> 0b1, 0b10000, 0b11111111 # Binary literals: base 2, digits 0-1 (3.X, 2.6+) (1, 16, 255) Here, the octal value 0o377, the hex value 0xFF, and the binary value 0b11111111 are all decimal 255. The F digits in the hex value, for example, each mean 15 in decimal and a 4-bit 1111 in binary, and reflect powers of 16. Thus, the hex value 0xFF and others convert to decimal values as follows: >>> 0xFF, (15 * (16 ** 1)) + (15 * (16 ** 0)) # How hex/binary map to decimal (255, 255) >>> 0x2F, (2 * (16 ** 1)) + (15 * (16 ** 0)) (47, 47) >>> 0xF, 0b1111, (1*(2**3) + 1*(2**2) + 1*(2**1) + 1*(2**0)) (15, 15, 15) Python prints integer values in decimal (base 10) by default but provides built-in func- tions that allow you to convert integers to other bases’ digit strings, in Python-literal form—useful when programs or users expect to see values in a given base: >>> oct(64), hex(64), bin(64) # Numbers=>digit strings ('0o100', '0x40', '0b1000000') The oct function converts decimal to octal, hex to hexadecimal, and bin to binary. To go the other way, the built-in int function converts a string of digits to an integer, and an optional second argument lets you specify the numeric base—useful for numbers read from files as strings instead of coded in scripts: >>> 64, 0o100, 0x40, 0b1000000 # Digits=>numbers in scripts and strings (64, 64, 64, 64) >>> int('64'), int('100', 8), int('40', 16), int('1000000', 2) (64, 64, 64, 64) >>> int('0x40', 16), int('0b1000000', 2) # Literal forms supported too (64, 64) The eval function, which you’ll meet later in this book, treats strings as though they were Python code. Therefore, it has a similar effect, but usually runs more slowly—it actually compiles and runs the string as a piece of a program, and it assumes the string being run comes from a trusted source—a clever user might be able to submit a string that deletes files on your machine, so be careful with this call: >>> eval('64'), eval('0o100'), eval('0x40'), eval('0b1000000') (64, 64, 64, 64) Finally, you can also convert integers to base-specific strings with string formatting method calls and expressions, which return just digits, not Python literal strings: >>> '{0:o}, {1:x}, {2:b}'.format(64, 64, 64) # Numbers=>digits, 2.6+ '100, 40, 1000000' >>> '%o, %x, %x, %X' % (64, 64, 255, 255) # Similar, in all Pythons '100, 40, ff, FF' 152 | Chapter 5: Numeric Types
- 205. String formatting is covered in more detail in Chapter 7. Two notes before moving on. First, per the start of this chapter, Python 2.X users should remember that you can code octals with simply a leading zero, the original octal format in Python: >>> 0o1, 0o20, 0o377 # New octal format in 2.6+ (same as 3.X) (1, 16, 255) >>> 01, 020, 0377 # Old octal literals in all 2.X (error in 3.X) (1, 16, 255) In 3.X, the syntax in the second of these examples generates an error. Even though it’s not an error in 2.X, be careful not to begin a string of digits with a leading zero unless you really mean to code an octal value. Python 2.X will treat it as base 8, which may not work as you’d expect—010 is always decimal 8 in 2.X, not decimal 10 (despite what you may or may not think!). This, along with symmetry with the hex and binary forms, is why the octal format was changed in 3.X—you must use 0o010 in 3.X, and probably should in 2.6 and 2.7 both for clarity and forward-compatibility with 3.X. Secondly, note that these literals can produce arbitrarily long integers. The following, for instance, creates an integer with hex notation and then displays it first in decimal and then in octal and binary with converters (run in 3.X here: in 2.X the decimal and octal displays have a trailing L to denote its separate long type, and octals display without the letter o): >>> X = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF >>> X 5192296858534827628530496329220095 >>> oct(X) '0o17777777777777777777777777777777777777' >>> bin(X) '0b111111111111111111111111111111111111111111111111111111111 ...and so on... 11111' Speaking of binary digits, the next section shows tools for processing individual bits. Bitwise Operations Besides the normal numeric operations (addition, subtraction, and so on), Python sup- ports most of the numeric expressions available in the C language. This includes oper- ators that treat integers as strings of binary bits, and can come in handy if your Python code must deal with things like network packets, serial ports, or packed binary data produced by a C program. We can’t dwell on the fundamentals of Boolean math here—again, those who must use it probably already know how it works, and others can often postpone the topic altogether—but the basics are straightforward. For instance, here are some of Python’s bitwise expression operators at work performing bitwise shift and Boolean operations on integers: >>> x = 1 # 1 decimal is 0001 in bits >>> x << 2 # Shift left 2 bits: 0100 Numbers in Action | 153
- 206. 4 >>> x | 2 # Bitwise OR (either bit=1): 0011 3 >>> x & 1 # Bitwise AND (both bits=1): 0001 1 In the first expression, a binary 1 (in base 2, 0001) is shifted left two slots to create a binary 4 (0100). The last two operations perform a binary OR to combine bits (0001| 0010 = 0011) and a binary AND to select common bits (0001&0001 = 0001). Such bit- masking operations allow us to encode and extract multiple flags and other values within a single integer. This is one area where the binary and hexadecimal number support in Python as of 3.0 and 2.6 become especially useful—they allow us to code and inspect numbers by bit- strings: >>> X = 0b0001 # Binary literals >>> X << 2 # Shift left 4 >>> bin(X << 2) # Binary digits string '0b100' >>> bin(X | 0b010) # Bitwise OR: either '0b11' >>> bin(X & 0b1) # Bitwise AND: both '0b1' This is also true for values that begin life as hex literals, or undergo base conversions: >>> X = 0xFF # Hex literals >>> bin(X) '0b11111111' >>> X ^ 0b10101010 # Bitwise XOR: either but not both 85 >>> bin(X ^ 0b10101010) '0b1010101' >>> int('01010101', 2) # Digits=>number: string to int per base 85 >>> hex(85) # Number=>digits: Hex digit string '0x55' Also in this department, Python 3.1 and 2.7 introduced a new integer bit_length method, which allows you to query the number of bits required to represent a number’s value in binary. You can often achieve the same effect by subtracting 2 from the length of the bin string using the len built-in function we met in Chapter 4 (to account for the leading “0b”), though it may be less efficient: >>> X = 99 >>> bin(X), X.bit_length(), len(bin(X)) - 2 ('0b1100011', 7, 7) >>> bin(256), (256).bit_length(), len(bin(256)) - 2 ('0b100000000', 9, 9) 154 | Chapter 5: Numeric Types
- 207. We won’t go into much more detail on such “bit twiddling” here. It’s supported if you need it, but bitwise operations are often not as important in a high-level language such as Python as they are in a low-level language such as C. As a rule of thumb, if you find yourself wanting to flip bits in Python, you should think about which language you’re really coding. As we’ll see in upcoming chapters, Python’s lists, dictionaries, and the like provide richer—and usually better—ways to encode information than bit strings, especially when your data’s audience includes readers of the human variety. Other Built-in Numeric Tools In addition to its core object types, Python also provides both built-in functions and standard library modules for numeric processing. The pow and abs built-in functions, for instance, compute powers and absolute values, respectively. Here are some exam- ples of the built-in math module (which contains most of the tools in the C language’s math library) and a few built-in functions at work in 3.3; as described earlier, some floating-point displays may show more or fewer digits in Pythons before 2.7 and 3.1: >>> import math >>> math.pi, math.e # Common constants (3.141592653589793, 2.718281828459045) >>> math.sin(2 * math.pi / 180) # Sine, tangent, cosine 0.03489949670250097 >>> math.sqrt(144), math.sqrt(2) # Square root (12.0, 1.4142135623730951) >>> pow(2, 4), 2 ** 4, 2.0 ** 4.0 # Exponentiation (power) (16, 16, 16.0) >>> abs(-42.0), sum((1, 2, 3, 4)) # Absolute value, summation (42.0, 10) >>> min(3, 1, 2, 4), max(3, 1, 2, 4) # Minimum, maximum (1, 4) The sum function shown here works on a sequence of numbers, and min and max accept either a sequence or individual arguments. There are a variety of ways to drop the decimal digits of floating-point numbers. We met truncation and floor earlier; we can also round, both numerically and for display purposes: >>> math.floor(2.567), math.floor(-2.567) # Floor (next-lower integer) (2, −3) >>> math.trunc(2.567), math.trunc(−2.567) # Truncate (drop decimal digits) (2, −2) >>> int(2.567), int(−2.567) # Truncate (integer conversion) (2, −2) >>> round(2.567), round(2.467), round(2.567, 2) # Round (Python 3.X version) Numbers in Action | 155
- 208. (3, 2, 2.57) >>> '%.1f' % 2.567, '{0:.2f}'.format(2.567) # Round for display (Chapter 7) ('2.6', '2.57') As we saw earlier, the last of these produces strings that we would usually print and supports a variety of formatting options. As also described earlier, the second-to-last test here will also output (3, 2, 2.57) prior to 2.7 and 3.1 if we wrap it in a print call torequestamoreuser-friendlydisplay.Stringformattingisstillsubtlydifferent,though, even in 3.X; round rounds and drops decimal digits but still produces a floating-point number in memory, whereas string formatting produces a string, not a number: >>> (1 / 3.0), round(1 / 3.0, 2), ('%.2f' % (1 / 3.0)) (0.3333333333333333, 0.33, '0.33') Interestingly, there are three ways to compute square roots in Python: using a module function, an expression, or a built-in function (if you’re interested in performance, we will revisit these in an exercise and its solution at the end of Part IV, to see which runs quicker): >>> import math >>> math.sqrt(144) # Module 12.0 >>> 144 ** .5 # Expression 12.0 >>> pow(144, .5) # Built-in 12.0 >>> math.sqrt(1234567890) # Larger numbers 35136.41828644462 >>> 1234567890 ** .5 35136.41828644462 >>> pow(1234567890, .5) 35136.41828644462 Notice that standard library modules such as math must be imported, but built-in func- tions such as abs and round are always available without imports. In other words, mod- ules are external components, but built-in functions live in an implied namespace that Python automatically searches to find names used in your program. This namespace simply corresponds to the standard library module called builtins in Python 3.X (and __builtin__ in 2.X). There is much more about name resolution in the function and module parts of this book; for now, when you hear “module,” think “import.” The standard library random module must be imported as well. This module provides an array of tools, for tasks such as picking a random floating-point number between 0 and 1, and selecting a random integer between two numbers: >>> import random >>> random.random() 0.5566014960423105 >>> random.random() # Random floats, integers, choices, shuffles 0.051308506597373515 156 | Chapter 5: Numeric Types
- 209. >>> random.randint(1, 10) 5 >>> random.randint(1, 10) 9 This module can also choose an item at random from a sequence, and shuffle a list of items randomly: >>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life']) 'Holy Grail' >>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life']) 'Life of Brian' >>> suits = ['hearts', 'clubs', 'diamonds', 'spades'] >>> random.shuffle(suits) >>> suits ['spades', 'hearts', 'diamonds', 'clubs'] >>> random.shuffle(suits) >>> suits ['clubs', 'diamonds', 'hearts', 'spades'] Though we’d need additional code to make this more tangible here, the random module can be useful for shuffling cards in games, picking images at random in a slideshow GUI, performing statistical simulations, and much more. We’ll deploy it again later in this book (e.g., in Chapter 20’s permutations case study), but for more details, see Python’s library manual. Other Numeric Types So far in this chapter, we’ve been using Python’s core numeric types—integer, floating point, and complex. These will suffice for most of the number crunching that most programmers will ever need to do. Python comes with a handful of more exotic numeric types, though, that merit a brief look here. Decimal Type Python 2.4 introduced a new core numeric type: the decimal object, formally known as Decimal. Syntactically, you create decimals by calling a function within an imported module, rather than running a literal expression. Functionally, decimals are like float- ing-point numbers, but they have a fixed number of decimal points. Hence, decimals are fixed-precision floating-point values. For example, with decimals, we can have a floating-point value that always retains just two decimal digits. Furthermore, we can specify how to round or truncate the extra decimal digits beyond the object’s cutoff. Although it generally incurs a performance penalty compared to the normal floating-point type, the decimal type is well suited to representing fixed-precision quantities like sums of money and can help you achieve better numeric accuracy. Other Numeric Types | 157
- 210. Decimal basics The last point merits elaboration. As previewed briefly when we explored comparisons, floating-point math is less than exact because of the limited space used to store values. For example, the following should yield zero, but it does not. The result is close to zero, but there are not enough bits to be precise here: >>> 0.1 + 0.1 + 0.1 - 0.3 # Python 3.3 5.551115123125783e-17 On Pythons prior to 3.1 and 2.7, printing the result to produce the user-friendly display format doesn’t completely help either, because the hardware related to floating-point math is inherently limited in terms of accuracy (a.k.a. precision). The following in 3.3 gives the same result as the previous output: >>> print(0.1 + 0.1 + 0.1 - 0.3) # Pythons < 2.7, 3.1 5.55111512313e-17 However, with decimals, the result can be dead-on: >>> from decimal import Decimal >>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3') Decimal('0.0') Asshownhere,wecanmakedecimalobjectsbycallingtheDecimal constructorfunction in the decimal module and passing in strings that have the desired number of decimal digits for the resulting object (using the str function to convert floating-point values to strings if needed). When decimals of different precision are mixed in expressions, Python converts up to the largest number of decimal digits automatically: >>> Decimal('0.1') + Decimal('0.10') + Decimal('0.10') - Decimal('0.30') Decimal('0.00') In Pythons 2.7, 3.1, and later, it’s also possible to create a decimal object from a floating- point object, with a call of the form decimal.Decimal.from_float(1.25), and recent Pythons allow floating-point numbers to be used directly. The conversion is exact but can sometimes yield a large default number of digits, unless they are fixed per the next section: >>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3) Decimal('2.775557561565156540423631668E-17') In Python 3.3 and later, the decimal module was also optimized to improve its perfor- mance radically: the reported speedup for the new version is 10X to 100X, depending on the type of program benchmarked. Setting decimal precision globally Other tools in the decimal module can be used to set the precision of all decimal num- bers, arrange error handling, and more. For instance, a context object in this module allows for specifying precision (number of decimal digits) and rounding modes (down, 158 | Chapter 5: Numeric Types
- 211. ceiling, etc.). The precision is applied globally for all decimals created in the calling thread: >>> import decimal >>> decimal.Decimal(1) / decimal.Decimal(7) # Default: 28 digits Decimal('0.1428571428571428571428571429') >>> decimal.getcontext().prec = 4 # Fixed precision >>> decimal.Decimal(1) / decimal.Decimal(7) Decimal('0.1429') >>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3) # Closer to 0 Decimal('1.110E-17') This is especially useful for monetary applications, where cents are represented as two decimal digits. Decimals are essentially an alternative to manual rounding and string formatting in this context: >>> 1999 + 1.33 # This has more digits in memory than displayed in 3.3 2000.33 >>> >>> decimal.getcontext().prec = 2 >>> pay = decimal.Decimal(str(1999 + 1.33)) >>> pay Decimal('2000.33') Decimal context manager In Python 2.6 and 3.0 and later, it’s also possible to reset precision temporarily by using the with context manager statement. The precision is reset to its original value on statement exit; in a new Python 3.3 session (per Chapter 3 the “...” here is Python’s interactive prompt for continuation lines in some interfaces and requires manual in- dentation; IDLE omits this prompt and indents for you): C:code> C:Python33python >>> import decimal >>> decimal.Decimal('1.00') / decimal.Decimal('3.00') Decimal('0.3333333333333333333333333333') >>> >>> with decimal.localcontext() as ctx: ... ctx.prec = 2 ... decimal.Decimal('1.00') / decimal.Decimal('3.00') ... Decimal('0.33') >>> >>> decimal.Decimal('1.00') / decimal.Decimal('3.00') Decimal('0.3333333333333333333333333333') Though useful, this statement requires much more background knowledge than you’ve obtained at this point; watch for coverage of the with statement in Chapter 34. Because use of the decimal type is still relatively rare in practice, I’ll defer to Python’s standard library manuals and interactive help for more details. And because decimals Other Numeric Types | 159
- 212. address some of the same floating-point accuracy issues as the fraction type, let’s move on to the next section to see how the two compare. Fraction Type Python 2.6 and 3.0 debuted a new numeric type, Fraction, which implements a rational number object. It essentially keeps both a numerator and a denominator explicitly, so as to avoid some of the inaccuracies and limitations of floating-point math. Like deci- mals, fractions do not map as closely to computer hardware as floating-point numbers. This means their performance may not be as good, but it also allows them to provide extra utility in a standard tool where required or useful. Fraction basics Fraction is a functional cousin to the Decimal fixed-precision type described in the prior section, as both can be used to address the floating-point type’s numerical inaccura- cies. It’s also used in similar ways—like Decimal, Fraction resides in a module; import its constructor and pass in a numerator and a denominator to make one (among other schemes). The following interaction shows how: >>> from fractions import Fraction >>> x = Fraction(1, 3) # Numerator, denominator >>> y = Fraction(4, 6) # Simplified to 2, 3 by gcd >>> x Fraction(1, 3) >>> y Fraction(2, 3) >>> print(y) 2/3 Once created, Fractions can be used in mathematical expressions as usual: >>> x + y Fraction(1, 1) >>> x − y # Results are exact: numerator, denominator Fraction(−1, 3) >>> x * y Fraction(2, 9) Fraction objects can also be created from floating-point number strings, much like decimals: >>> Fraction('.25') Fraction(1, 4) >>> Fraction('1.25') Fraction(5, 4) >>> >>> Fraction('.25') + Fraction('1.25') Fraction(3, 2) 160 | Chapter 5: Numeric Types
- 213. Numeric accuracy in fractions and decimals Notice that this is different from floating-point-type math, which is constrained by the underlying limitations of floating-point hardware. To compare, here are the same op- erations run with floating-point objects, and notes on their limited accuracy—they may display fewer digits in recent Pythons than they used to, but they still aren’t exact values in memory: >>> a = 1 / 3.0 # Only as accurate as floating-point hardware >>> b = 4 / 6.0 # Can lose precision over many calculations >>> a 0.3333333333333333 >>> b 0.6666666666666666 >>> a + b 1.0 >>> a - b -0.3333333333333333 >>> a * b 0.2222222222222222 This floating-point limitation is especially apparent for values that cannot be repre- sented accurately given their limited number of bits in memory. Both Fraction and Decimal provide ways to get exact results, albeit at the cost of some speed and code verbosity. For instance, in the following example (repeated from the prior section), floating-point numbers do not accurately give the zero answer expected, but both of the other types do: >>> 0.1 + 0.1 + 0.1 - 0.3 # This should be zero (close, but not exact) 5.551115123125783e-17 >>> from fractions import Fraction >>> Fraction(1, 10) + Fraction(1, 10) + Fraction(1, 10) - Fraction(3, 10) Fraction(0, 1) >>> from decimal import Decimal >>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3') Decimal('0.0') Moreover, fractions and decimals both allow more intuitive and accurate results than floating points sometimes can, in different ways—by using rational representation and by limiting precision: >>> 1 / 3 # Use a ".0" in Python 2.X for true "/" 0.3333333333333333 >>> Fraction(1, 3) # Numeric accuracy, two ways Fraction(1, 3) >>> import decimal >>> decimal.getcontext().prec = 2 >>> Decimal(1) / Decimal(3) Decimal('0.33') Other Numeric Types | 161
- 214. In fact, fractions both retain accuracy and automatically simplify results. Continuing the preceding interaction: >>> (1 / 3) + (6 / 12) # Use a ".0" in Python 2.X for true "/" 0.8333333333333333 >>> Fraction(6, 12) # Automatically simplified Fraction(1, 2) >>> Fraction(1, 3) + Fraction(6, 12) Fraction(5, 6) >>> decimal.Decimal(str(1/3)) + decimal.Decimal(str(6/12)) Decimal('0.83') >>> 1000.0 / 1234567890 8.100000073710001e-07 >>> Fraction(1000, 1234567890) # Substantially simpler! Fraction(100, 123456789) Fraction conversions and mixed types To support fraction conversions, floating-point objects now have a method that yields their numerator and denominator ratio, fractions have a from_float method, and float accepts a Fraction as an argument. Trace through the following interaction to see how this pans out (the * in the second test is special syntax that expands a tuple into individual arguments; more on this when we study function argument passing in Chapter 18): >>> (2.5).as_integer_ratio() # float object method (5, 2) >>> f = 2.5 >>> z = Fraction(*f.as_integer_ratio()) # Convert float -> fraction: two args >>> z # Same as Fraction(5, 2) Fraction(5, 2) >>> x # x from prior interaction Fraction(1, 3) >>> x + z Fraction(17, 6) # 5/2 + 1/3 = 15/6 + 2/6 >>> float(x) # Convert fraction -> float 0.3333333333333333 >>> float(z) 2.5 >>> float(x + z) 2.8333333333333335 >>> 17 / 6 2.8333333333333335 >>> Fraction.from_float(1.75) # Convert float -> fraction: other way Fraction(7, 4) 162 | Chapter 5: Numeric Types
- 215. >>> Fraction(*(1.75).as_integer_ratio()) Fraction(7, 4) Finally, some type mixing is allowed in expressions, though Fraction must sometimes be manually propagated to retain accuracy. Study the following interaction to see how this works: >>> x Fraction(1, 3) >>> x + 2 # Fraction + int -> Fraction Fraction(7, 3) >>> x + 2.0 # Fraction + float -> float 2.3333333333333335 >>> x + (1./3) # Fraction + float -> float 0.6666666666666666 >>> x + (4./3) 1.6666666666666665 >>> x + Fraction(4, 3) # Fraction + Fraction -> Fraction Fraction(5, 3) Caveat: although you can convert from floating point to fraction, in some cases there is an unavoidable precision loss when you do so, because the number is inaccurate in its original floating-point form. When needed, you can simplify such results by limiting the maximum denominator value: >>> 4.0 / 3 1.3333333333333333 >>> (4.0 / 3).as_integer_ratio() # Precision loss from float (6004799503160661, 4503599627370496) >>> x Fraction(1, 3) >>> a = x + Fraction(*(4.0 / 3).as_integer_ratio()) >>> a Fraction(22517998136852479, 13510798882111488) >>> 22517998136852479 / 13510798882111488. # 5 / 3 (or close to it!) 1.6666666666666667 >>> a.limit_denominator(10) # Simplify to closest fraction Fraction(5, 3) For more details on the Fraction type, experiment further on your own and consult the Python 2.6, 2.7, and 3.X library manuals and other documentation. Sets Besides decimals, Python 2.4 also introduced a new collection type, the set—an unor- dered collection of unique and immutable objects that supports operations corre- sponding to mathematical set theory. By definition, an item appears only once in a set, no matter how many times it is added. Accordingly, sets have a variety of applications, especially in numeric and database-focused work. Other Numeric Types | 163
- 216. Because sets are collections of other objects, they share some behavior with objects such as lists and dictionaries that are outside the scope of this chapter. For example, sets are iterable, can grow and shrink on demand, and may contain a variety of object types. As we’ll see, a set acts much like the keys of a valueless dictionary, but it supports extra operations. However, because sets are unordered and do not map keys to values, they are neither sequence nor mapping types; they are a type category unto themselves. Moreover, be- cause sets are fundamentally mathematical in nature (and for many readers, may seem more academic and be used much less often than more pervasive objects like diction- aries), we’ll explore the basic utility of Python’s set objects here. Set basics in Python 2.6 and earlier There are a few ways to make sets today, depending on which Python you use. Since this book covers all, let’s begin with the case for 2.6 and earlier, which also is available (and sometimes still required) in later Pythons; we’ll refine this for 2.7 and 3.X exten- sions in a moment. To make a set object, pass in a sequence or other iterable object to the built-in set function: >>> x = set('abcde') >>> y = set('bdxyz') You get back a set object, which contains all the items in the object passed in (notice that sets do not have a positional ordering, and so are not sequences—their order is arbitrary and may vary per Python release): >>> x set(['a', 'c', 'b', 'e', 'd']) # Pythons <= 2.6 display format Sets made this way support the common mathematical set operations with expres- sion operators. Note that we can’t perform the following operations on plain sequences like strings, lists, and tuples—we must create sets from them by passing them to set in order to apply these tools: >>> x − y # Difference set(['a', 'c', 'e']) >>> x | y # Union set(['a', 'c', 'b', 'e', 'd', 'y', 'x', 'z']) >>> x & y # Intersection set(['b', 'd']) >>> x ^ y # Symmetric difference (XOR) set(['a', 'c', 'e', 'y', 'x', 'z']) >>> x > y, x < y # Superset, subset (False, False) The notable exception to this rule is the in set membership test—this expression is also defined to work on all other collection types, where it also performs membership (or a 164 | Chapter 5: Numeric Types
- 217. search, if you prefer to think in procedural terms). Hence, we do not need to convert things like strings and lists to sets to run this test: >>> 'e' in x # Membership (sets) True >>> 'e' in 'Camelot', 22 in [11, 22, 33] # But works on other types too (True, True) In addition to expressions, the set object provides methods that correspond to these operations and more, and that support set changes—the set add method inserts one item, update is an in-place union, and remove deletes an item by value (run a dir call on any set instance or the set type name to see all the available methods). Assuming x and y are still as they were in the prior interaction: >>> z = x.intersection(y) # Same as x & y >>> z set(['b', 'd']) >>> z.add('SPAM') # Insert one item >>> z set(['b', 'd', 'SPAM']) >>> z.update(set(['X', 'Y'])) # Merge: in-place union >>> z set(['Y', 'X', 'b', 'd', 'SPAM']) >>> z.remove('b') # Delete one item >>> z set(['Y', 'X', 'd', 'SPAM']) As iterable containers, sets can also be used in operations such as len, for loops, and list comprehensions. Because they are unordered, though, they don’t support sequence operations like indexing and slicing: >>> for item in set('abc'): print(item * 3) aaa ccc bbb Finally, although the set expressions shown earlier generally require two sets, their method-based counterparts can often work with any iterable type as well: >>> S = set([1, 2, 3]) >>> S | set([3, 4]) # Expressions require both to be sets set([1, 2, 3, 4]) >>> S | [3, 4] TypeError: unsupported operand type(s) for |: 'set' and 'list' >>> S.union([3, 4]) # But their methods allow any iterable set([1, 2, 3, 4]) >>> S.intersection((1, 3, 5)) set([1, 3]) >>> S.issubset(range(-5, 5)) True Other Numeric Types | 165
- 218. For more details on set operations, see Python’s library reference manual or a reference book. Although set operations can be coded manually in Python with other types, like lists and dictionaries (and often were in the past), Python’s built-in sets use efficient algorithms and implementation techniques to provide quick and standard operation. Set literals in Python 3.X and 2.7 If you think sets are “cool,” they eventually became noticeably cooler, with new syntax for set literals and comprehensions initially added in the Python 3.X line only, but back- ported to Python 2.7 by popular demand. In these Pythons we can still use the set built- in to make set objects, but also a new set literal form, using the curly braces formerly reserved for dictionaries. In 3.X and 2.7, the following are equivalent: set([1, 2, 3, 4]) # Built-in call (all) {1, 2, 3, 4} # Newer set literals (2.7, 3.X) This syntax makes sense, given that sets are essentially like valueless dictionaries— because a set’s items are unordered, unique, and immutable, the items behave much like a dictionary’s keys. This operational similarity is even more striking given that dictionary key lists in 3.X are view objects, which support set-like behavior such as intersections and unions (see Chapter 8 for more on dictionary view objects). Regardless of how a set is made, 3.X displays it using the new literal format. Python 2.7 accepts the new literal syntax, but still displays sets using the 2.6 display form of the prior section. In all Pythons, the set built-in is still required to create empty sets and to build sets from existing iterable objects (short of using set comprehensions, discussed later in this chapter), but the new literal is convenient for initializing sets of known structure. Here’s what sets look like in 3.X; it’s the same in 2.7, except that set results display with 2.X’s set([...]) notation, and item order may vary per version (which by defini- tion is irrelevant in sets anyhow): C:code> c:python33python >>> set([1, 2, 3, 4]) # Built-in: same as in 2.6 {1, 2, 3, 4} >>> set('spam') # Add all items in an iterable {'s', 'a', 'p', 'm'} >>> {1, 2, 3, 4} # Set literals: new in 3.X (and 2.7) {1, 2, 3, 4} >>> S = {'s', 'p', 'a', 'm'} >>> S {'s', 'a', 'p', 'm'} >>> S.add('alot') # Methods work as before >>> S {'s', 'a', 'p', 'alot', 'm'} All the set processing operations discussed in the prior section work the same in 3.X, but the result sets print differently: 166 | Chapter 5: Numeric Types
- 219. >>> S1 = {1, 2, 3, 4} >>> S1 & {1, 3} # Intersection {1, 3} >>> {1, 5, 3, 6} | S1 # Union {1, 2, 3, 4, 5, 6} >>> S1 - {1, 3, 4} # Difference {2} >>> S1 > {1, 3} # Superset True Note that {} is still a dictionary in all Pythons. Empty sets must be created with the set built-in, and print the same way: >>> S1 - {1, 2, 3, 4} # Empty sets print differently set() >>> type({}) # Because {} is an empty dictionary <class 'dict'> >>> S = set() # Initialize an empty set >>> S.add(1.23) >>> S {1.23} As in Python 2.6 and earlier, sets created with 3.X/2.7 literals support the same meth- ods, some of which allow general iterable operands that expressions do not: >>> {1, 2, 3} | {3, 4} {1, 2, 3, 4} >>> {1, 2, 3} | [3, 4] TypeError: unsupported operand type(s) for |: 'set' and 'list' >>> {1, 2, 3}.union([3, 4]) {1, 2, 3, 4} >>> {1, 2, 3}.union({3, 4}) {1, 2, 3, 4} >>> {1, 2, 3}.union(set([3, 4])) {1, 2, 3, 4} >>> {1, 2, 3}.intersection((1, 3, 5)) {1, 3} >>> {1, 2, 3}.issubset(range(-5, 5)) True Immutable constraints and frozen sets Sets are powerful and flexible objects, but they do have one constraint in both 3.X and 2.X that you should keep in mind—largely because of their implementation, sets can only contain immutable (a.k.a. “hashable”) object types. Hence, lists and dictionaries cannot be embedded in sets, but tuples can if you need to store compound values. Tuples compare by their full values when used in set operations: >>> S {1.23} >>> S.add([1, 2, 3]) # Only immutable objects work in a set TypeError: unhashable type: 'list' Other Numeric Types | 167
- 220. >>> S.add({'a':1}) TypeError: unhashable type: 'dict' >>> S.add((1, 2, 3)) >>> S # No list or dict, but tuple OK {1.23, (1, 2, 3)} >>> S | {(4, 5, 6), (1, 2, 3)} # Union: same as S.union(...) {1.23, (4, 5, 6), (1, 2, 3)} >>> (1, 2, 3) in S # Membership: by complete values True >>> (1, 4, 3) in S False Tuples in a set, for instance, might be used to represent dates, records, IP addresses, and so on (more on tuples later in this part of the book). Sets may also contain modules, type objects, and more. Sets themselves are mutable too, and so cannot be nested in other sets directly; if you need to store a set inside another set, the frozenset built-in call works just like set but creates an immutable set that cannot change and thus can be embedded in other sets. Set comprehensions in Python 3.X and 2.7 In addition to literals, Python 3.X grew a set comprehension construct that was back- ported for use to Python 2.7 too. Like the 3.X set literal, 2.7 accepts its syntax, but displays its results in 2.X set notation. The set comprehension expression is similar in form to the list comprehension we previewed in Chapter 4, but is coded in curly braces instead of square brackets and run to make a set instead of a list. Set comprehensions run a loop and collect the result of an expression on each iteration; a loop variable gives access to the current iteration value for use in the collection expression. The result is a new set you create by running the code, with all the normal set behavior. Here is a set comprehension in 3.3 (again, result display and order differs in 2.7): >>> {x ** 2 for x in [1, 2, 3, 4]} # 3.X/2.7 set comprehension {16, 1, 4, 9} In this expression, the loop is coded on the right, and the collection expression is coded on the left (x ** 2). As for list comprehensions, we get back pretty much what this expression says: “Give me a new set containing X squared, for every X in a list.” Com- prehensions can also iterate across other kinds of objects, such as strings (the first of the following examples illustrates the comprehension-based way to make a set from an existing iterable): >>> {x for x in 'spam'} # Same as: set('spam') {'m', 's', 'p', 'a'} >>> {c * 4 for c in 'spam'} # Set of collected expression results {'pppp', 'aaaa', 'ssss', 'mmmm'} >>> {c * 4 for c in 'spamham'} {'pppp', 'aaaa', 'hhhh', 'ssss', 'mmmm'} >>> S = {c * 4 for c in 'spam'} 168 | Chapter 5: Numeric Types
- 221. >>> S | {'mmmm', 'xxxx'} {'pppp', 'xxxx', 'mmmm', 'aaaa', 'ssss'} >>> S & {'mmmm', 'xxxx'} {'mmmm'} Because the rest of the comprehensions story relies upon underlying concepts we’re not yet prepared to address, we’ll postpone further details until later in this book. In Chapter 8, we’ll meet a first cousin in 3.X and 2.7, the dictionary comprehension, and I’ll have much more to say about all comprehensions—list, set, dictionary, and gener- ator—later on, especially in Chapter 14 and Chapter 20. As we’ll learn there, all com- prehensions support additional syntax not shown here, including nested loops and if tests, which can be challenging to understand until you’ve had a chance to study larger statements. Why sets? Set operations have a variety of common uses, some more practical than mathematical. For example, because items are stored only once in a set, sets can be used to filter duplicates out of other collections, though items may be reordered in the process be- cause sets are unordered in general. Simply convert the collection to a set, and then convert it back again (sets work in the list call here because they are iterable, another technical artifact that we’ll unearth later): >>> L = [1, 2, 1, 3, 2, 4, 5] >>> set(L) {1, 2, 3, 4, 5} >>> L = list(set(L)) # Remove duplicates >>> L [1, 2, 3, 4, 5] >>> list(set(['yy', 'cc', 'aa', 'xx', 'dd', 'aa'])) # But order may change ['cc', 'xx', 'yy', 'dd', 'aa'] Sets can be used to isolate differences in lists, strings, and other iterable objects too— simply convert to sets and take the difference—though again the unordered nature of sets means that the results may not match that of the originals. The last two of the following compare attribute lists of string object types in 3.X (results vary in 2.7): >>> set([1, 3, 5, 7]) - set([1, 2, 4, 5, 6]) # Find list differences {3, 7} >>> set('abcdefg') - set('abdghij') # Find string differences {'c', 'e', 'f'} >>> set('spam') - set(['h', 'a', 'm']) # Find differences, mixed {'p', 's'} >>> set(dir(bytes)) - set(dir(bytearray)) # In bytes but not bytearray {'__getnewargs__'} >>> set(dir(bytearray)) - set(dir(bytes)) {'append', 'copy', '__alloc__', '__imul__', 'remove', 'pop', 'insert', ...more...] You can also use sets to perform order-neutral equality tests by converting to a set before the test, because order doesn’t matter in a set. More formally, two sets are equal if and Other Numeric Types | 169
- 222. only if every element of each set is contained in the other—that is, each is a subset of the other, regardless of order. For instance, you might use this to compare the outputs of programs that should work the same but may generate results in different order. Sortingbeforetestinghas the sameeffectforequality, but setsdon’trelyonanexpensive sort, and sorts order their results to support additional magnitude tests that sets do not (greater, less, and so on): >>> L1, L2 = [1, 3, 5, 2, 4], [2, 5, 3, 4, 1] >>> L1 == L2 # Order matters in sequences False >>> set(L1) == set(L2) # Order-neutral equality True >>> sorted(L1) == sorted(L2) # Similar but results ordered True >>> 'spam' == 'asmp', set('spam') == set('asmp'), sorted('spam') == sorted('asmp') (False, True, True) Sets can also be used to keep track of where you’ve already been when traversing a graph or other cyclic structure. For example, the transitive module reloader and inher- itance tree lister examples we’ll study in Chapter 25 and Chapter 31, respectively, must keep track of items visited to avoid loops, as Chapter 19 discusses in the abstract. Using a list in this context is inefficient because searches require linear scans. Although re- cording states visited as keys in a dictionary is efficient, sets offer an alternative that’s essentially equivalent (and may be more or less intuitive, depending on whom you ask). Finally, sets are also convenient when you’re dealing with large data sets (database query results, for example)—the intersection of two sets contains objects common to both categories, and the union contains all items in either set. To illustrate, here’s a somewhat more realistic example of set operations at work, applied to lists of people in a hypothetical company, using 3.X/2.7 set literals and 3.X result displays (use set in 2.6 and earlier): >>> engineers = {'bob', 'sue', 'ann', 'vic'} >>> managers = {'tom', 'sue'} >>> 'bob' in engineers # Is bob an engineer? True >>> engineers & managers # Who is both engineer and manager? {'sue'} >>> engineers | managers # All people in either category {'bob', 'tom', 'sue', 'vic', 'ann'} >>> engineers - managers # Engineers who are not managers {'vic', 'ann', 'bob'} >>> managers - engineers # Managers who are not engineers {'tom'} >>> engineers > managers # Are all managers engineers? (superset) False 170 | Chapter 5: Numeric Types
- 223. >>> {'bob', 'sue'} < engineers # Are both engineers? (subset) True >>> (managers | engineers) > managers # All people is a superset of managers True >>> managers ^ engineers # Who is in one but not both? {'tom', 'vic', 'ann', 'bob'} >>> (managers | engineers) - (managers ^ engineers) # Intersection! {'sue'} You can find more details on set operations in the Python library manual and some mathematical and relational database theory texts. Also stay tuned for Chapter 8’s revival of some of the set operations we’ve seen here, in the context of dictionary view objects in Python 3.X. Booleans Some may argue that the Python Boolean type, bool, is numeric in nature because its two values, True and False, are just customized versions of the integers 1 and 0 that print themselves differently. Although that’s all most programmers need to know, let’s explore this type in a bit more detail. More formally, Python today has an explicit Boolean data type called bool, with the values True and False available as preassigned built-in names. Internally, the names True and False are instances of bool, which is in turn just a subclass (in the object- oriented sense) of the built-in integer type int. True and False behave exactly like the integers 1 and 0, except that they have customized printing logic—they print them- selves as the words True and False, instead of the digits 1 and 0. bool accomplishes this by redefining str and repr string formats for its two objects. Because of this customization, the output of Boolean expressions typed at the interac- tive prompt prints as the words True and False instead of the older and less obvious 1 and 0. In addition, Booleans make truth values more explicit in your code. For instance, an infinite loop can now be coded as while True: instead of the less intuitive while 1:. Similarly, flags can be initialized more clearly with flag = False. We’ll discuss these statements further in Part III. Again, though, for most practical purposes, you can treat True and False as though they are predefined variables set to integers 1 and 0. Most programmers had been pre- assigning True and False to 1 and 0 anyway; the bool type simply makes this standard. Its implementation can lead to curious results, though. Because True is just the integer 1 with a custom display format, True + 4 yields integer 5 in Python! >>> type(True) <class 'bool'> >>> isinstance(True, int) True Other Numeric Types | 171
- 224. >>> True == 1 # Same value True >>> True is 1 # But a different object: see the next chapter False >>> True or False # Same as: 1 or 0 True >>> True + 4 # (Hmmm) 5 Since you probably won’t come across an expression like the last of these in real Python code, you can safely ignore any of its deeper metaphysical implications. We’ll revisit Booleans in Chapter 9 to define Python’s notion of truth, and again in Chapter 12 to see how Boolean operators like and and or work. Numeric Extensions Finally, although Python core numeric types offer plenty of power for most applica- tions, there is a large library of third-party open source extensions available to address more focused needs. Because numeric programming is a popular domain for Python, you’ll find a wealth of advanced tools. For example, if you need to do serious number crunching, an optional extension for Python called NumPy (Numeric Python) provides advanced numeric programming tools, such as a matrix data type, vector processing, and sophisticated computation libraries. Hardcore scientific programming groups at places like Los Alamos and NASA use Python with NumPy to implement the sorts of tasks they previously coded in C++, FORTRAN, or Matlab. The combination of Python and NumPy is often com- pared to a free, more flexible version of Matlab—you get NumPy’s performance, plus the Python language and its libraries. Because it’s so advanced, we won’t talk further about NumPy in this book. You can find additional support for advanced numeric programming in Python, including graphics and plotting tools, extended precision floats, statistics libraries, and the pop- ular SciPy package by searching the Web. Also note that NumPy is currently an optional extension; it doesn’t come with Python and must be installed separately, though you’ll probably want to do so if you care enough about this domain to look it up on the Web. Chapter Summary This chapter has taken a tour of Python’s numeric object types and the operations we can apply to them. Along the way, we met the standard integer and floating-point types, as well as some more exotic and less commonly used types such as complex numbers, decimals, fractions, and sets. We also explored Python’s expression syntax, type con- versions, bitwise operations, and various literal forms for coding numbers in scripts. 172 | Chapter 5: Numeric Types
- 225. Later in this part of the book, we’ll continue our in-depth type tour by filling in some details about the next object type—the string. In the next chapter, however, we’ll take some time to explore the mechanics of variable assignment in more detail than we have here. This turns out to be perhaps the most fundamental idea in Python, so make sure you check out the next chapter before moving on. First, though, it’s time to take the usual chapter quiz. Test Your Knowledge: Quiz 1. What is the value of the expression 2 * (3 + 4) in Python? 2. What is the value of the expression 2 * 3 + 4 in Python? 3. What is the value of the expression 2 + 3 * 4 in Python? 4. What tools can you use to find a number’s square root, as well as its square? 5. What is the type of the result of the expression 1 + 2.0 + 3? 6. How can you truncate and round a floating-point number? 7. How can you convert an integer to a floating-point number? 8. How would you display an integer in octal, hexadecimal, or binary notation? 9. How might you convert an octal, hexadecimal, or binary string to a plain integer? Test Your Knowledge: Answers 1. The value will be 14, the result of 2 * 7, because the parentheses force the addition to happen before the multiplication. 2. The value will be 10, the result of 6 + 4. Python’s operator precedence rules are applied in the absence of parentheses, and multiplication has higher precedence than (i.e., happens before) addition, per Table 5-2. 3. This expression yields 14, the result of 2 + 12, for the same precedence reasons as in the prior question. 4. Functions for obtaining the square root, as well as pi, tangents, and more, are available in the imported math module. To find a number’s square root, import math and call math.sqrt(N). To get a number’s square, use either the exponent expression X ** 2 or the built-in function pow(X, 2). Either of these last two can also compute the square root when given a power of 0.5 (e.g., X ** .5). 5. The result will be a floating-point number: the integers are converted up to floating point, the most complex type in the expression, and floating-point math is used to evaluate it. 6. The int(N) and math.trunc(N) functions truncate, and the round(N, digits) func- tion rounds. We can also compute the floor with math.floor(N) and round for display with string formatting operations. Test Your Knowledge: Answers | 173
- 226. 7. The float(I) function converts an integer to a floating point; mixing an integer with a floating point within an expression will result in a conversion as well. In some sense, Python 3.X / division converts too—it always returns a floating-point result that includes the remainder, even if both operands are integers. 8. The oct(I) and hex(I) built-in functions return the octal and hexadecimal string forms for an integer. The bin(I) call also returns a number’s binary digits string in Pythons 2.6, 3.0, and later. The % string formatting expression and format string method also provide targets for some such conversions. 9. The int(S, base) function can be used to convert from octal and hexadecimal strings to normal integers (pass in 8, 16, or 2 for the base). The eval(S) function can be used for this purpose too, but it’s more expensive to run and can have security issues. Note that integers are always stored in binary form in computer memory; these are just display string format conversions. 174 | Chapter 5: Numeric Types
- 227. CHAPTER 6 The Dynamic Typing Interlude In the prior chapter, we began exploring Python’s core object types in depth bystudying Python numeric types and operations. We’ll resume our object type tour in the next chapter, but before we move on, it’s important that you get a handle on what may be the most fundamental idea in Python programming and is certainly the basis of much of both the conciseness and flexibility of the Python language—dynamic typing, and the polymorphism it implies. As you’ll see here and throughout this book, in Python, we do not declare the specific types of the objects our scripts use. In fact, most programs should not even care about specific types; in exchange, they are naturally applicable in more contexts than we can sometimes even plan ahead for. Because dynamic typing is the root of this flexibility, and is also a potential stumbling block for newcomers, let’s take a brief side trip to explore the model here. The Case of the Missing Declaration Statements If you have a background in compiled or statically typed languages like C, C++, or Java, you might find yourself a bit perplexed at this point in the book. So far, we’ve been using variables without declaring their existence or their types, and it somehow works. When we type a = 3 in an interactive session or program file, for instance, how does Python know that a should stand for an integer? For that matter, how does Python know what a is at all? Once you start asking such questions, you’ve crossed over into the domain of Python’s dynamic typing model. In Python, types are determined automatically at runtime, not in response to declarations in your code. This means that you never declare variables ahead of time (a concept that is perhaps simpler to grasp if you keep in mind that it all boils down to variables, objects, and the links between them). 175
- 228. Variables, Objects, and References As you’ve seen in many of the examples used so far in this book, when you run an assignment statement such as a = 3 in Python, it works even if you’ve never told Python to use the name a as a variable, or that a should stand for an integer-type object. In the Python language, this all pans out in a very natural way, as follows: Variable creation A variable (i.e., name), like a, is created when your code first assigns it a value. Future assignments change the value of the already created name. Technically, Python detects some names before your code runs, but you can think of it as though initial assignments make variables. Variable types A variable never has any type information or constraints associated with it. The notion of type lives with objects, not names. Variables are generic in nature; they always simply refer to a particular object at a particular point in time. Variable use When avariableappears in anexpression,itisimmediatelyreplacedwiththeobject that it currently refers to, whatever that may be. Further, all variables must be explicitly assigned before they can be used; referencing unassigned variables results in errors. In sum, variables are created when assigned, can reference any type of object, and must be assigned before they are referenced. This means that you never need to declare names used by your script, but you must initialize names before you can update them; coun- ters, for example, must be initialized to zero before you can add to them. This dynamic typing model is strikingly different from the typing model of traditional languages. When you are first starting out, the model is usually easier to understand if you keep clear the distinction between names and objects. For example, when we say this to assign a variable a value: >>> a = 3 # Assign a name to an object at least conceptually, Python will perform three distinct steps to carry out the request. These steps reflect the operation of all assignments in the Python language: 1. Create an object to represent the value 3. 2. Create the variable a, if it does not yet exist. 3. Link the variable a to the new object 3. The net result will be a structure inside Python that resembles Figure 6-1. As sketched, variables and objects are stored in different parts of memory and are associated by links (the link is shown as a pointer in the figure). Variables always link to objects and never to other variables, but larger objects may link to other objects (for instance, a list object has links to the objects it contains). 176 | Chapter 6: The Dynamic Typing Interlude
- 229. These links from variables to objects are called references in Python—that is, a reference is a kind of association, implemented as a pointer in memory.1 Whenever the variables are later used (i.e., referenced), Python automatically follows the variable-to-object links. This is all simpler than the terminology may imply. In concrete terms: • Variables are entries in a system table, with spaces for links to objects. • Objects are pieces of allocated memory, with enough space to represent the values for which they stand. • References are automatically followed pointers from variables to objects. At least conceptually, each time you generate a new value in your script by running an expression, Python creates a new object (i.e., a chunk of memory) to represent that value. As an optimization, Python internally caches and reuses certain kinds of un- changeable objects, such as small integers and strings (each 0 is not really a new piece of memory—more on this caching behavior later). But from a logical perspective, it works as though each expression’s result value is a distinct object and each object is a distinct piece of memory. Technically speaking, objects have more structure than just enough space to represent their values. Each object also has two standard header fields: a type designator used to mark the type of the object, and a reference counter used to determine when it’s OK to reclaim the object. To understand how these two header fields factor into the model, we need to move on. Types Live with Objects, Not Variables To see how object types come into play, watch what happens if we assign a variable multiple times: Figure 6-1. Names and objects after running the assignment a = 3. Variable a becomes a reference to the object 3. Internally, the variable is really a pointer to the object’s memory space created by running the literal expression 3. 1. Readers with a background in C may find Python references similar to C pointers (memory addresses). In fact, references are implemented as pointers, and they often serve the same roles, especially with objects that can be changed in place (more on this later). However, because references are always automatically dereferenced when used, you can never actually do anything useful with a reference itself; this is a feature that eliminates a vast category of C bugs. But you can think of Python references as C “void*” pointers, which are automatically followed whenever used. The Case of the Missing Declaration Statements | 177
- 230. >>> a = 3 # It's an integer >>> a = 'spam' # Now it's a string >>> a = 1.23 # Now it's a floating point This isn’t typical Python code, but it does work—a starts out as an integer, then be- comes a string, and finally becomes a floating-point number. This example tends to look especially odd to ex-C programmers, as it appears as though the type of a changes from integer to string when we say a = 'spam'. However, that’s not really what’s happening. In Python, things work more simply. Names have no types; as stated earlier, types live with objects, not names. In the pre- ceding listing, we’ve simply changed a to reference different objects. Because variables have no type, we haven’t actually changed the type of the variable a; we’ve simply made the variable reference a different type of object. In fact, again, all we can ever say about a variable in Python is that it references a particular object at a particular point in time. Objects, on the other hand, know what type they are—each object contains a header field that tags the object with its type. The integer object 3, for example, will contain the value 3, plus a designator that tells Python that the object is an integer (strictly speaking, a pointer to an object called int, the name of the integer type). The type designator of the 'spam' string object points to the string type (called str) instead. Because objects know their types, variables don’t have to. To recap, types are associated with objects in Python, not with variables. In typical code, a given variable usually will reference just one kind of object. Because this isn’t a requirement, though, you’ll find that Python code tends to be much more flexible than you may be accustomed to—if you use Python well, your code might work on many types automatically. I mentioned that objects have two header fields, a type designator and a reference counter. To understand the latter of these, we need to move on and take a brief look at what happens at the end of an object’s life. Objects Are Garbage-Collected In the prior section’s listings, we assigned the variable a to different types of objects in each assignment. But when we reassign a variable, what happens to the value it was previously referencing? For example, after the following statements, what happens to the object 3? >>> a = 3 >>> a = 'spam' The answer is that in Python, whenever a name is assigned to a new object, the space held by the prior object is reclaimed if it is not referenced by any other name or object. This automatic reclamation of objects’ space is known as garbage collection, and makes life much simpler for programmers of languages like Python that support it. 178 | Chapter 6: The Dynamic Typing Interlude
- 231. To illustrate, consider the following example, which sets the name x to a different object on each assignment: >>> x = 42 >>> x = 'shrubbery' # Reclaim 42 now (unless referenced elsewhere) >>> x = 3.1415 # Reclaim 'shrubbery' now >>> x = [1, 2, 3] # Reclaim 3.1415 now First, notice that x is set to a different type of object each time. Again, though this is not really the case, the effect is as though the type of x is changing over time. Remember, in Python types live with objects, not names. Because names are just generic references to objects, this sort of code works naturally. Second, notice that references to objects are discarded along the way. Each time x is assigned to a new object, Python reclaims the prior object’s space. For instance, when it is assigned the string 'shrubbery', the object 42 is immediately reclaimed (assuming it is not referenced anywhere else)—that is, the object’s space is automatically thrown back into the free space pool, to be reused for a future object. Internally, Python accomplishes this feat by keeping a counter in every object that keeps track of the number of references currently pointing to that object. As soon as (and exactly when) this counter drops to zero, the object’s memory space is automatically reclaimed. In the preceding listing, we’re assuming that each time x is assigned to a new object, the prior object’s reference counter drops to zero, causing it to be reclaimed. The most immediately tangible benefit of garbage collection is that it means you can use objects liberally without ever needing to allocate or free up space in your script. Python will clean up unused space for you as your program runs. In practice, this eliminates a substantial amount of bookkeeping code required in lower-level languages such as C and C++. More on Python Garbage Collection Technically speaking, Python’s garbage collection is based mainly upon reference coun- ters, as described here; however, it also has a component that detects and reclaims objects with cyclic references in time. This component can be disabled if you’re sure that your code doesn’t create cycles, but it is enabled by default. Circular references are a classic issue in reference count garbage collectors. Because references are implemented as pointers, it’s possible for an object to reference itself, or reference another object that does. For example, exercise 3 at the end of Part I and its solution in Appendix D show how to create a cycle easily by embedding a reference to a list within itself (e.g., L.append(L)). The same phenomenon can occur for assignments to attributes of objects created from user-defined classes. Though relatively rare, be- cause the reference counts for such objects never drop to zero, they must be treated specially. For more details on Python’s cycle detector, see the documentation for the gc module in Python’s library manual. The best news here is that garbage-collection-based mem- ory management is implemented for you in Python, by people highly skilled at the task. The Case of the Missing Declaration Statements | 179
- 232. Also note that this chapter’s description of Python’s garbage collector applies to the standard Python (a.k.a. CPython) only; Chapter 2’s alternative implementations such as Jython, IronPython, and PyPy may use different schemes, though the net effect in all is similar—unused space is reclaimed for you automatically, if not always as imme- diately. Shared References So far, we’ve seen what happens as a single variable is assigned references to objects. Now let’s introduce another variable into our interaction and watch what happens to its names and objects: >>> a = 3 >>> b = a Typing these two statements generates the scene captured in Figure 6-2. The second command causes Python to create the variable b; the variable a is being used and not assigned here, so it is replaced with the object it references (3), and b is made to reference that object. The net effect is that the variables a and b wind up referencing the same object (that is, pointing to the same chunk of memory). Figure 6-2. Names and objects after next running the assignment b = a. Variable b becomes a reference to the object 3. Internally, the variable is really a pointer to the object’s memory space created by running the literal expression 3. This scenario in Python—with multiple names referencing the same object—is usually called a shared reference (and sometimes just a shared object). Note that the names a and b are not linked to each other directly when this happens; in fact, there is no way to ever link a variable to another variable in Python. Rather, both variables point to the same object via their references. Next, suppose we extend the session with one more statement: >>> a = 3 >>> b = a >>> a = 'spam' As with all Python assignments, this statement simply makes a new object to represent the string value 'spam' and sets a to reference this new object. It does not, however, 180 | Chapter 6: The Dynamic Typing Interlude
- 233. change the value of b; b still references the original object, the integer 3. The resulting reference structure is shown in Figure 6-3. Thesamesortofthingwouldhappenifwechangedb to'spam' instead—theassignment would change only b, not a. This behavior also occurs if there are no type differences at all. For example, consider these three statements: >>> a = 3 >>> b = a >>> a = a + 2 In this sequence, the same events transpire. Python makes the variable a reference the object 3 and makes b reference the same object as a, as in Figure 6-2; as before, the last assignment then sets a to a completely different object (in this case, the integer 5, which is the result of the + expression). It does not change b as a side effect. In fact, there is no way to ever overwrite the value of the object 3—as introduced in Chapter 4, integers are immutable and thus can never be changed in place. One way to think of this is that, unlike in some languages, in Python variables are always pointers to objects, not labels of changeable memory areas: setting a variable to a new value does not alter the original object, but rather causes the variable to reference an entirely different object. The net effect is that assignment to a variable itself can impact only the single variable being assigned. When mutable objects and in-place changes enter the equation, though, the picture changes somewhat; to see how, let’s move on. Shared References and In-Place Changes As you’ll see later in this part’s chapters, there are objects and operations that perform in-place object changes—Python’s mutable types, including lists, dictionaries, and sets. For instance, an assignment to an offset in a list actually changes the list object itself in place, rather than generating a brand-new list object. Figure 6-3. Names and objects after finally running the assignment a = ‘spam’. Variable a references the new object (i.e., piece of memory) created by running the literal expression ‘spam’, but variable b still refers to the original object 3. Because this assignment is not an in-place change to the object 3, it changes only variable a, not b. Shared References | 181
- 234. Though you must take it somewhat on faith at this point in the book, this distinction can matter much in your programs. For objects that support such in-place changes, you need to be more aware of shared references, since a change from one name may impact others. Otherwise, your objects may seem to change for no apparent reason. Given that all assignments are based on references (including function argument pass- ing), it’s a pervasive potential. To illustrate, let’s take another look at the list objects introduced in Chapter 4. Recall that lists, which do support in-place assignments to positions, are simply collections of other objects, coded in square brackets: >>> L1 = [2, 3, 4] >>> L2 = L1 L1 here is a list containing the objects 2, 3, and 4. Items inside a list are accessed by their positions, so L1[0] refers to object 2, the first item in the list L1. Of course, lists are also objects in their own right, just like integers and strings. After running the two prior assignments, L1 and L2 reference the same shared object, just like a and b in the prior example (see Figure 6-2). Now say that, as before, we extend this interaction to say the following: >>> L1 = 24 This assignment simply sets L1 to a different object; L2 still references the original list. If we change this statement’s syntax slightly, however, it has a radically different effect: >>> L1 = [2, 3, 4] # A mutable object >>> L2 = L1 # Make a reference to the same object >>> L1[0] = 24 # An in-place change >>> L1 # L1 is different [24, 3, 4] >>> L2 # But so is L2! [24, 3, 4] Really, we haven’t changed L1 itself here; we’ve changed a component of the object that L1 references. This sort of change overwrites part of the list object’s value in place. Because the list object is shared by (referenced from) other variables, though, an in- place change like this doesn’t affect only L1—that is, you must be aware that when you make such changes, they can impact other parts of your program. In this example, the effect shows up in L2 as well because it references the same object as L1. Again, we haven’t actually changed L2, either, but its value will appear different because it refers to an object that has been overwritten in place. This behavior only occurs for mutable objects that support in-place changes, and is usually what you want, but you should be aware of how it works, so that it’s expected. It’s also just the default: if you don’t want such behavior, you can request that Python copy objects instead of making references. There are a variety of ways to copy a list, includingusingthebuilt-inlist functionandthestandardlibrarycopy module.Perhaps 182 | Chapter 6: The Dynamic Typing Interlude
- 235. the most common way is to slice from start to finish (see Chapter 4 and Chapter 7 for more on slicing): >>> L1 = [2, 3, 4] >>> L2 = L1[:] # Make a copy of L1 (or list(L1), copy.copy(L1), etc.) >>> L1[0] = 24 >>> L1 [24, 3, 4] >>> L2 # L2 is not changed [2, 3, 4] Here, the change made through L1 is not reflected in L2 because L2 references a copy of the object L1 references, not the original; that is, the two variables point to different pieces of memory. Note that this slicing technique won’t work on the other major mutable core types, dictionaries and sets, because they are not sequences—to copy a dictionary or set, instead use their X.copy() method call (lists have one as of Python 3.3 as well), or pass the original object to their type names, dict and set. Also, note that the standard library copy module has a call for copying any object type generically, as well as a call for copying nested object structures—a dictionary with nested lists, for example: import copy X = copy.copy(Y) # Make top-level "shallow" copy of any object Y X = copy.deepcopy(Y) # Make deep copy of any object Y: copy all nested parts We’ll explore lists and dictionaries in more depth, and revisit the concept of shared references and copies, in Chapter 8 and Chapter 9. For now, keep in mind that objects that can be changed in place (that is, mutable objects) are always open to these kinds of effects in any code they pass through. In Python, this includes lists, dictionaries, sets, and some objects defined with class statements. If this is not the desired behavior, you can simply copy your objects as needed. Shared References and Equality In the interest of full disclosure, I should point out that the garbage-collection behavior described earlier in this chapter may be more conceptual than literal for certain types. Consider these statements: >>> x = 42 >>> x = 'shrubbery' # Reclaim 42 now? BecausePythoncachesandreusessmallintegersandsmallstrings,asmentionedearlier, the object 42 here is probably not literally reclaimed; instead, it will likely remain in a system table to be reused the next time you generate a 42 in your code. Most kinds of objects, though, are reclaimed immediately when they are no longer referenced; for those that are not, the caching mechanism is irrelevant to your code. For instance, because of Python’s reference model, there are two different ways to check for equality in a Python program. Let’s create a shared reference to demonstrate: Shared References | 183
- 236. >>> L = [1, 2, 3] >>> M = L # M and L reference the same object >>> L == M # Same values True >>> L is M # Same objects True The first technique here, the == operator, tests whether the two referenced objects have the same values; this is the method almost always used for equality checks in Python. The second method, the is operator, instead tests for object identity—it returns True only if both names point to the exact same object, so it is a much stronger form of equality testing and is rarely applied in most programs. Really, is simply compares the pointers that implement references, and it serves as a way to detect shared references in your code if needed. It returns False if the names point to equivalent but different objects, as is the case when we run two different literal expressions: >>> L = [1, 2, 3] >>> M = [1, 2, 3] # M and L reference different objects >>> L == M # Same values True >>> L is M # Different objects False Now, watch what happens when we perform the same operations on small numbers: >>> X = 42 >>> Y = 42 # Should be two different objects >>> X == Y True >>> X is Y # Same object anyhow: caching at work! True In this interaction, X and Y should be == (same value), but not is (same object) because we ran two different literal expressions (42). Because small integers and strings are cached and reused, though, is tells us they reference the same single object. In fact, if you really want to look under the hood, you can always ask Python how many references there are to an object: the getrefcount function in the standard sys module returns the object’s reference count. When I ask about the integer object 1 in the IDLE GUI, for instance, it reports 647 reuses of this same object (most of which are in IDLE’s system code, not mine, though this returns 173 outside IDLE so Python must be hoarding 1s as well): >>> import sys >>> sys.getrefcount(1) # 647 pointers to this shared piece of memory 647 This object caching and reuse is irrelevant to your code (unless you run the is check!). Because you cannot change immutable numbers or strings in place, it doesn’t matter how many references there are to the same object—every reference will always see the 184 | Chapter 6: The Dynamic Typing Interlude
- 237. same, unchanging value. Still, this behavior reflects one of the many ways Python op- timizes its model for execution speed. Dynamic Typing Is Everywhere Of course, you don’t really need to draw name/object diagrams with circles and arrows to use Python. When you’re starting out, though, it sometimes helps you understand unusual cases if you can trace their reference structures as we’ve done here. If a mutable object changes out from under you when passed around your program, for example, chances are you are witnessing some of this chapter’s subject matter firsthand. Moreover, even if dynamic typing seems a little abstract at this point, you probably will care about it eventually. Because everything seems to work by assignment and refer- ences in Python, a basic understanding of this model is useful in many different con- texts. As you’ll see, it works the same in assignment statements, function arguments, for loop variables, module imports, class attributes, and more. The good news is that there is just one assignment model in Python; once you get a handle on dynamic typing, you’ll find that it works the same everywhere in the language. At the most practical level, dynamic typing means there is less code for you to write. Just as importantly, though, dynamic typing is also the root of Python’s polymor- phism, a concept we introduced in Chapter 4 and will revisit again later in this book. Because we do not constrain types in Python code, it is both concise and highly flexible. As you’ll see, when used well, dynamic typing—and the polymorphism it implies— produces code that automatically adapts to new requirements as your systems evolve. “Weak” References You may occasionally see the term “weak reference” in the Python world. This is a somewhat advanced tool, but is related to the reference model we’ve explored here, and like the is operator, can’t really be understood without it. In short, a weak reference, implemented by the weakref standard library module, is a reference to an object that does not by itself prevent the referenced object from being garbage-collected. If the last remaining references to an object are weak references, the object is reclaimed and the weak references to it are automatically deleted (or otherwise notified). This can be useful in dictionary-based caches of large objects, for example; otherwise, the cache’s reference alone would keep the object in memory indefinitely. Still, this is really just a special-case extension to the reference model. For more details, see Python’s library manual. Dynamic Typing Is Everywhere | 185
- 238. Chapter Summary This chapter took a deeper look at Python’s dynamic typing model—that is, the way that Python keeps track of object types for us automatically, rather than requiring us to code declaration statements in our scripts. Along the way, we learned how variables and objects are associated by references in Python; we also explored the idea of garbage collection, learned how shared references to objects can affect multiple variables, and saw how references impact the notion of equality in Python. Because there is just one assignment model in Python, and because assignment pops up everywhere in the language, it’s important that you have a handle on the model before moving on. The following quiz should help you review some of this chapter’s ideas. After that, we’ll resume our core object tour in the next chapter, with strings. Test Your Knowledge: Quiz 1. Consider the following three statements. Do they change the value printed for A? A = "spam" B = A B = "shrubbery" 2. Consider these three statements. Do they change the printed value of A? A = ["spam"] B = A B[0] = "shrubbery" 3. How about these—is A changed now? A = ["spam"] B = A[:] B[0] = "shrubbery" Test Your Knowledge: Answers 1. No: A still prints as "spam". When B is assigned to the string "shrubbery", all that happens is that the variable B is reset to point to the new string object. A and B initially share (i.e., reference/point to) the same single string object "spam", but two names are never linked together in Python. Thus, setting B to a different object has no effect on A. The same would be true if the last statement here were B = B + 'shrubbery',bytheway—theconcatenationwouldmakeanewobjectforitsresult, which would then be assigned to B only. We can never overwrite a string (or num- ber, or tuple) in place, because strings are immutable. 2. Yes: A now prints as ["shrubbery"]. Technically, we haven’t really changed either A or B; instead, we’ve changed part of the object they both reference (point to) by overwriting that object in place through the variable B. Because A references the same object as B, the update is reflected in A as well. 186 | Chapter 6: The Dynamic Typing Interlude
- 239. 3. No: A still prints as ["spam"]. The in-place assignment through B has no effect this time because the slice expression made a copy of the list object before it was as- signed to B. After the second assignment statement, there are two different list objects that have the same value (in Python, we say they are ==, but not is). The third statement changes the value of the list object pointed to by B, but not that pointed to by A. Test Your Knowledge: Answers | 187
- 241. CHAPTER 7 String Fundamentals So far, we’ve studied numbers and explored Python’s dynamic typing model. The next major type on our in-depth core object tour is the Python string—an ordered collection of characters used to store and represent text- and bytes-based information. We looked briefly at strings in Chapter 4. Here, we will revisit them in more depth, filling in some of the details we skipped earlier. This Chapter’s Scope Before we get started, I also want to clarify what we won’t be covering here. Chap- ter 4 briefly previewed Unicode strings and files—tools for dealing with non-ASCII text. Unicode is a key tool for some programmers, especially those who work in the Internet domain. It can pop up, for example, in web pages, email content and headers, FTP transfers, GUI APIs, directory tools, and HTML, XML and JSON text. At the same time, Unicode can be a heavy topic for programmers just starting out, and many (or most) of the Python programmers I meet today still do their jobs in blissful ignorance of the entire topic. In light of that, this book relegates most of the Unicode story to Chapter 37 of its Advanced Topics part as optional reading, and focuses on string basics here. That is, this chapter tells only part of the string story in Python—the part that most scripts use and most programmers need to know. It explores the fundamental str string type, which handles ASCII text, and works the same regardless of which version of Python you use. Despite this intentionally limited scope, because str also handles Uni- code in Python 3.X, and the separate unicode type works almost identically to str in 2.X, everything we learn here will apply directly to Unicode processing too. Unicode: The Short Story For readers who do care about Unicode, I’d like to also provide a quick summary of its impacts and pointers for further study. From a formal perspective, ASCII is a simple 189
- 242. form of Unicode text, but just one of many possible encodings and alphabets. Text from non-English-speaking sources may use very different letters, and may be encoded very differently when stored in files. As we saw in Chapter 4, Python addresses this by distinguishing between text and binary data, with distinct string object types and file interfaces for each. This support varies per Python line: • In Python 3.X there are three string types: str is used for Unicode text (including ASCII), bytes is used for binary data (including encoded text), and bytearray is a mutable variant of bytes. Files work in two modes: text, which represents content as str and implements Unicode encodings, and binary, which deals in raw bytes and does no data translation. • In Python 2.X, unicode strings represent Unicode text, str strings handle both 8- bit text and binary data, and bytearray is available in 2.6 and later as a back-port from 3.X. Normal files’ content is simply bytes represented as str, but a codecs module opens Unicode text files, handles encodings, and represents content as unicode objects. Despite such version differences, if and when you do need to care about Unicode you’ll find that it is a relatively minor extension—once text is in memory, it’s a Python string of characters that supports all the basics we’ll study in this chapter. In fact, the primary distinction of Unicode often lies in the translation (a.k.a. encoding) step required to move it to and from files. Beyond that, it’s largely just string processing. Again, though, because most programmers don’t need to come to grips with Unicode details up front, I’ve moved most of them to Chapter 37. When you’re ready to learn about these more advanced string concepts, I encourage you to see both their preview in Chapter 4 and the full Unicode and bytes disclosure in Chapter 37 after reading the string fundamentals material here. For this chapter, we’ll focus on the basic string type and its operations. As you’ll find, the techniques we’ll study here also apply directly to the more advanced string types in Python’s toolset. String Basics From a functional perspective, strings can be used to represent just about anything that can be encoded as text or bytes. In the text department, this includes symbols and words (e.g., your name), contents of text files loaded into memory, Internet addresses, Python source code, and so on. Strings can also be used to hold the raw bytes used for media files and network transfers, and both the encoded and decoded forms of non- ASCII Unicode text used in internationalized programs. You may have used strings in other languages, too. Python’s strings serve the same role as character arrays in languages such as C, but they are a somewhat higher-level tool 190 | Chapter 7: String Fundamentals
- 243. than arrays. Unlike in C, in Python, strings come with a powerful set of processing tools. Also unlike languages such as C, Python has no distinct type for individual char- acters; instead, you just use one-character strings. Strictly speaking, Python strings are categorized as immutable sequences, meaning that the characters they contain have a left-to-right positional order and that they cannot be changed in place. In fact, strings are the first representative of the larger class of objects called sequences that we will study here. Pay special attention to the sequence operations introduced in this chapter, because they will work the same on other se- quence types we’ll explore later, such as lists and tuples. Table 7-1 previews common string literals and operations we will discuss in this chap- ter. Empty strings are written as a pair of quotation marks (single or double) with nothing in between, and there are a variety of ways to code strings. For processing, strings support expression operations such as concatenation (combining strings), slic- ing (extracting sections), indexing (fetching by offset), and so on. Besides expressions, Python also provides a set of string methods that implement common string-specific tasks, as well as modules for more advanced text-processing tasks such as pattern matching. We’ll explore all of these later in the chapter. Table 7-1. Common string literals and operations Operation Interpretation S = '' Empty string S = "spam's" Double quotes, same as single S = 'snptax00m' Escape sequences S = """...multiline...""" Triple-quoted block strings S = r'tempspam' Raw strings (no escapes) B = b'spxc4m' Byte strings in 2.6, 2.7, and 3.X (Chapter 4, Chapter 37) U = u'spu00c4m' Unicode strings in 2.X and 3.3+ (Chapter 4, Chapter 37) S1 + S2 S * 3 Concatenate, repeat S[i] S[i:j] len(S) Index, slice, length "a %s parrot" % kind String formatting expression "a {0} parrot".format(kind) String formatting method in 2.6, 2.7, and 3.X S.find('pa') S.rstrip() S.replace('pa', 'xx') S.split(',') String methods (see ahead for all 43): search, remove whitespace, replacement, split on delimiter, String Basics | 191
- 244. Operation Interpretation S.isdigit() S.lower() S.endswith('spam') 'spam'.join(strlist) S.encode('latin-1') B.decode('utf8') content test, case conversion, end test, delimiter join, Unicode encoding, Unicode decoding, etc. (see Table 7-3) for x in S: print(x) 'spam' in S [c * 2 for c in S] map(ord, S) Iteration, membership re.match('sp(.*)am', line) Pattern matching: library module Beyond the core set of string tools in Table 7-1, Python also supports more advanced pattern-based string processing with the standard library’s re (for “regular expression”) module, introduced in Chapter 4 and Chapter 36, and even higher-level text processing tools such as XML parsers (discussed briefly in Chapter 37). This book’s scope, though, is focused on the fundamentals represented by Table 7-1. To cover the basics, this chapter begins with an overview of string literal forms and string expressions, then moves on to look at more advanced tools such as string meth- ods and formatting. Python comes with many string tools, and we won’t look at them all here; the complete story is chronicled in the Python library manual and reference books. Our goal here is to explore enough commonly used tools to give you a repre- sentative sample; methods we won’t see in action here, for example, are largely anal- ogous to those we will. String Literals By and large, strings are fairly easy to use in Python. Perhaps the most complicated thing about them is that there are so many ways to write them in your code: • Single quotes: 'spa"m' • Double quotes: "spa'm" • Triple quotes: '''... spam ...''', """... spam ...""" • Escape sequences: "stpna0m" • Raw strings: r"C:newtest.spm" • Bytes literals in 3.X and 2.6+ (see Chapter 4, Chapter 37): b'spx01am' • Unicode literals in 2.X and 3.3+ (see Chapter 4, Chapter 37): u'eggsu0020spam' 192 | Chapter 7: String Fundamentals
- 245. The single- and double-quoted forms are by far the most common; the others serve specialized roles, and we’re postponing further discussion of the last two advanced forms until Chapter 37. Let’s take a quick look at all the other options in turn. Single- and Double-Quoted Strings Are the Same Around Python strings, single- and double-quote characters are interchangeable. That is, string literals can be written enclosed in either two single or two double quotes— the two forms work the same and return the same type of object. For example, the following two strings are identical, once coded: >>> 'shrubbery', "shrubbery" ('shrubbery', 'shrubbery') The reason for supporting both is that it allows you to embed a quote character of the other variety inside a string without escaping it with a backslash. You may embed a single-quote character in a string enclosed in double-quote characters, and vice versa: >>> 'knight"s', "knight's" ('knight"s', "knight's") This book generally prefers to use single quotes around strings just because they are marginally easier to read, except in cases where a single quote is embedded in the string. This is a purely subjective style choice, but Python displays strings this way too and most Python programmers do the same today, so you probably should too. Note that the comma is important here. Without it, Python automatically concate- nates adjacent string literals in any expression, although it is almost as simple to add a + operator between them to invoke concatenation explicitly (as we’ll see in Chap- ter 12, wrapping this form in parentheses also allows it to span multiple lines): >>> title = "Meaning " 'of' " Life" # Implicit concatenation >>> title 'Meaning of Life' Adding commas between these strings would result in a tuple, not a string. Also notice in all of these outputs that Python prints strings in single quotes unless they embed one.Ifneeded,youcanalsoembedquotecharactersbyescapingthemwithbackslashes: >>> 'knight's', "knight"s" ("knight's", 'knight"s') To understand why, you need to know how escapes work in general. Escape Sequences Represent Special Characters The last example embedded a quote inside a string by preceding it with a backslash. This is representative of a general pattern in strings: backslashes are used to introduce special character codings known as escape sequences. String Literals | 193
- 246. Escape sequences let us embed characters in strings that cannot easily be typed on a keyboard. The character , and one or more characters following it in the string literal, are replaced with a single character in the resulting string object, which has the binary value specified by the escape sequence. For example, here is a five-character string that embeds a newline and a tab: >>> s = 'anbtc' The two characters n stand for a single character—the binary value of the newline character in your character set (in ASCII, character code 10). Similarly, the sequence t is replaced with the tab character. The way this string looks when printed depends on how you print it. The interactive echo shows the special characters as escapes, but print interprets them instead: >>> s 'anbtc' >>> print(s) a b c To be completely sure how many actual characters are in this string, use the built-in len function—it returns the actual number of characters in a string, regardless of how it is coded or displayed: >>> len(s) 5 This string is five characters long: it contains an ASCII a, a newline character, an ASCII b, and so on. If you’re accustomed to all-ASCII text, it’s tempting to think of this result as meaning 5 bytes too, but you probably shouldn’t. Really, “bytes” has no meaning in the Unicode world. For one thing, the string object is probably larger in memory in Python. More critically, string content and length both reflect code points (iden- tifying numbers) in Unicode-speak, where a single character does not necessarily map directly to a single byte, either when encoded in files or when stored in memory. This mapping might hold true for simple 7-bit ASCII text, but even this depends on both the external encoding type and the internal storage scheme used. Under UTF-16, for example, AS- CII characters are multiple bytes in files, and they may be 1, 2, or 4 bytes in memory depending on how Python allocates their space. For other, non-ASCII text, whose characters’ values might be too large to fit in an 8-bit byte, the character-to-byte mapping doesn’t apply at all. In fact, 3.X defines str strings formally as sequences of Unicode code points, not bytes, to make this clear. There’s more on how strings are stored internally in Chapter 37 if you care to know. For now, to be safest, think characters instead of bytes in strings. Trust me on this; as an ex- C programmer, I had to break the habit too! 194 | Chapter 7: String Fundamentals
- 247. Note that the original backslash characters in the preceding result are not really stored with the string in memory; they are used only to describe special character values to be stored in the string. For coding such special characters, Python recognizes a full set of escape code sequences, listed in Table 7-2. Table 7-2. String backslash characters Escape Meaning newline Ignored (continuation line) Backslash (stores one ) ' Single quote (stores ') " Double quote (stores ") a Bell b Backspace f Formfeed n Newline (linefeed) r Carriage return t Horizontal tab v Vertical tab xhh Character with hex value hh (exactly 2 digits) ooo Character with octal value ooo (up to 3 digits) 0 Null: binary 0 character (doesn’t end string) N{ id } Unicode database ID uhhhh Unicode character with 16-bit hex value Uhhhhhhhh Unicode character with 32-bit hex valuea other Not an escape (keeps both and other) a TheUhhhh...escapesequencetakesexactlyeighthexadecimaldigits(h);bothuandUarerecognizedonlyinUnicodestringliterals in 2.X, but can be used in normal strings (which are Unicode) in 3.X. In a 3.X bytes literal, hexadecimal and octal escapes denote the byte withthegivenvalue;inastringliteral,theseescapesdenoteaUnicodecharacterwiththegivencode-pointvalue.ThereismoreonUnicode escapes in Chapter 37. Some escape sequences allow you to embed absolute binary values into the characters of a string. For instance, here’s a five-character string that embeds two characters with binary zero values (coded as octal escapes of one digit): >>> s = 'a0b0c' >>> s 'ax00bx00c' >>> len(s) 5 In Python, a zero (null) character like this does not terminate a string the way a “null byte” typically does in C. Instead, Python keeps both the string’s length and text in memory. In fact, no character terminates a string in Python. Here’s a string that is all String Literals | 195
- 248. absolute binary escape codes—a binary 1 and 2 (coded in octal), followed by a binary 3 (coded in hexadecimal): >>> s = '001002x03' >>> s 'x01x02x03' >>> len(s) 3 Notice that Python displays nonprintable characters in hex, regardless of how they were specified. You can freely combine absolute value escapes and the more symbolic escape types in Table 7-2. The following string contains the characters “spam”, a tab and newline, and an absolute zero value character coded in hex: >>> S = "stpnax00m" >>> S 'stpnax00m' >>> len(S) 7 >>> print(S) s p a m This becomes more important to know when you process binary data files in Python. Because their contents are represented as strings in your scripts, it’s OK to process binary files that contain any sorts of binary byte values—when opened in binary modes, files return strings of raw bytes from the external file (there’s much more on files in Chapter 4, Chapter 9, and Chapter 37). Finally, as the last entry in Table 7-2 implies, if Python does not recognize the character aftera asbeingavalid escape code,itsimply keepsthe backslashintheresultingstring: >>> x = "C:pycode" # Keeps literally (and displays it as ) >>> x 'C:pycode' >>> len(x) 10 However, unless you’re able to commit all of Table 7-2 to memory (and there are ar- guably better uses for your neurons!), you probably shouldn’t rely on this behavior. To code literal backslashes explicitly such that they are retained in your strings, double them up ( is an escape for one ) or use raw strings; the next section shows how. Raw Strings Suppress Escapes As we’ve seen, escape sequences are handy for embedding special character codes within strings. Sometimes, though, the special treatment of backslashes for introducing escapes can lead to trouble. It’s surprisingly common, for instance, to see Python new- comers in classes trying to open a file with a filename argument that looks something like this: myfile = open('C:newtext.dat', 'w') 196 | Chapter 7: String Fundamentals
- 249. thinking that they will open a file called text.dat in the directory C:new. The problem here is that n is taken to stand for a newline character, and t is replaced with a tab. In effect, the call tries to open a file named C:(newline)ew(tab)ext.dat, with usually less- than-stellar results. This is just the sort of thing that raw strings are useful for. If the letter r (uppercase or lowercase) appears just before the opening quote of a string, it turns off the escape mechanism. The result is that Python retains your backslashes literally, exactly as you type them. Therefore, to fix the filename problem, just remember to add the letter r on Windows: myfile = open(r'C:newtext.dat', 'w') Alternatively, because two backslashes are really an escape sequence for one backslash, you can keep your backslashes by simply doubling them up: myfile = open('C:newtext.dat', 'w') In fact, Python itself sometimes uses this doubling scheme when it prints strings with embedded backslashes: >>> path = r'C:newtext.dat' >>> path # Show as Python code 'C:newtext.dat' >>> print(path) # User-friendly format C:newtext.dat >>> len(path) # String length 15 As with numeric representation, the default format at the interactive prompt prints results as if they were code, and therefore escapes backslashes in the output. The print statement provides a more user-friendly format that shows that there is actually only one backslash in each spot. To verify this is the case, you can check the result of the built-in len function, which returns the number of characters in the string, inde- pendent of display formats. If you count the characters in the print(path) output, you’ll see that there really is just 1 character per backslash, for a total of 15. Besides directory paths on Windows, raw strings are also commonly used for regular expressions (text pattern matching, supported with the re module introduced in Chap- ter 4 and Chapter 37). Also note that Python scripts can usually use forward slashes in directory paths on Windows and Unix because Python tries to interpret paths portably (i.e., 'C:/new/text.dat' works when opening files, too). Raw strings are useful if you code paths using native Windows backslashes, though. String Literals | 197
- 250. Despite its role, even a raw string cannot end in a single backslash, be- cause the backslash escapes the following quote character—you still must escape the surrounding quote character to embed it in the string. That is, r"..." is not a valid string literal—a raw string cannot end in an odd number of backslashes. If you need to end a raw string with a single backslash, you can use two and slice off the second (r'1nbtc '[:-1]), tack one on manually (r'1nbtc' + ''), or skip the raw string syntax and just double up the backslashes in a normal string ('1 nbtc'). All three of these forms create the same eight-character string containing three backslashes. Triple Quotes Code Multiline Block Strings So far, you’ve seen single quotes, double quotes, escapes, and raw strings in action. Python also has a triple-quoted string literal format, sometimes called a block string, that is a syntactic convenience for coding multiline text data. This form begins with three quotes (of either the single or double variety), is followed by any number of lines of text, and is closed with the same triple-quote sequence that opened it. Single and double quotes embedded in the string’s text may be, but do not have to be, escaped— the string does not end until Python sees three unescaped quotes of the same kind used to start the literal. For example (the “...” here is Python’s prompt for continuation lines outside IDLE: don’t type it yourself): >>> mantra = """Always look ... on the bright ... side of life.""" >>> >>> mantra 'Always lookn on the brightnside of life.' This string spans three lines. As we learned in Chapter 3, in some interfaces, the inter- active prompt changes to ... on continuation lines like this, but IDLE simply drops down one line; this book shows listings in both forms, so extrapolate as needed. Either way, Python collects all the triple-quoted text into a single multiline string, with em- bedded newline characters (n) at the places where your code has line breaks. Notice that, as in the literal, the second line in the result has leading spaces, but the third does not—what you type is truly what you get. To see the string with the newlines inter- preted, print it instead of echoing: >>> print(mantra) Always look on the bright side of life. In fact, triple-quoted strings will retain all the enclosed text, including any to the right of your code that you might intend as comments. So don’t do this—put your comments above or below the quoted text, or use the automatic concatenation of adjacent strings mentioned earlier, with explicit newlines if desired, and surrounding parentheses to 198 | Chapter 7: String Fundamentals
- 251. allow line spans (again, more on this latter form when we study syntax rules in Chap- ter 10 and Chapter 12): >>> menu = """spam # comments here added to string! ... eggs # ditto ... """ >>> menu 'spam # comments here added to string!neggs # ditton' >>> menu = ( ... "spamn" # comments here ignored ... "eggsn" # but newlines not automatic ... ) >>> menu 'spamneggsn' Triple-quoted strings are useful anytime you need multiline text in your program; for example, to embed multiline error messages or HTML, XML, or JSON code in your Python source code files. You can embed such blocks directly in your scripts by triple- quoting without resorting to external text files or explicit concatenation and newline characters. Triple-quoted strings are also commonly used for documentation strings, which are string literals that are taken as comments when they appear at specific points in your file (more on these later in the book). These don’t have to be triple-quoted blocks, but they usually are to allow for multiline comments. Finally, triple-quoted strings are also sometimes used as a “horribly hackish” way to temporarily disable lines of code during development (OK, it’s not really too horrible, and it’s actually a fairly common practice today, but it wasn’t the intent). If you wish to turn off a few lines of code and run your script again, simply put three quotes above and below them, like this: X = 1 """ import os # Disable this code temporarily print(os.getcwd()) """ Y = 2 I said this was hackish because Python really might make a string out of the lines of code disabled this way, but this is probably not significant in terms of performance. For large sections of code, it’s also easier than manually adding hash marks before each line and later removing them. This is especially true if you are using a text editor that does not have support for editing Python code specifically. In Python, practicality often beats aesthetics. String Literals | 199
- 252. Strings in Action Once you’ve created a string with the literal expressions we just met, you will almost certainly want to do things with it. This section and the next two demonstrate string expressions, methods, and formatting—the first line of text-processing tools in the Python language. Basic Operations Let’s begin by interacting with the Python interpreter to illustrate the basic string op- erations listed earlier in Table 7-1. You can concatenate strings using the + operator and repeat them using the * operator: % python >>> len('abc') # Length: number of items 3 >>> 'abc' + 'def' # Concatenation: a new string 'abcdef' >>> 'Ni!' * 4 # Repetition: like "Ni!" + "Ni!" + ... 'Ni!Ni!Ni!Ni!' The len built-in function here returns the length of a string (or any other object with a length). Formally, adding two string objects with + creates a new string object, with the contents of its operands joined, and repetition with * is like adding a string to itself a number of times. In both cases, Python lets you create arbitrarily sized strings; there’s no need to predeclare anything in Python, including the sizes of data structures—you simply create string objects as needed and let Python manage the underlying memory space automatically (see Chapter 6 for more on Python’s memory management “garbage collector”). Repetition may seem a bit obscure at first, but it comes in handy in a surprising number of contexts. For example, to print a line of 80 dashes, you can count up to 80, or let Python count for you: >>> print('------- ...more... ---') # 80 dashes, the hard way >>> print('-' * 80) # 80 dashes, the easy way Notice that operator overloading is at work here already: we’re using the same + and * operators that perform addition and multiplication when using numbers. Python does the correct operation because it knows the types of the objects being added and mul- tiplied. But be careful: the rules aren’t quite as liberal as you might expect. For instance, Python doesn’t allow you to mix numbers and strings in + expressions: 'abc'+9 raises an error instead of automatically converting 9 to a string. As shown in the last row in Table 7-1, you can also iterate over strings in loops using for statements, which repeat actions, and test membership for both characters and substrings with the in expression operator, which is essentially a search. For substrings, in is much like the str.find() method covered later in this chapter, but it returns a 200 | Chapter 7: String Fundamentals
- 253. Boolean result instead of the substring’s position (the following uses a 3.X print call and may leave your cursor a bit indented; in 2.X say print c, instead): >>> myjob = "hacker" >>> for c in myjob: print(c, end=' ') # Step through items, print each (3.X form) ... h a c k e r >>> "k" in myjob # Found True >>> "z" in myjob # Not found False >>> 'spam' in 'abcspamdef' # Substring search, no position returned True The for loop assigns a variable to successive items in a sequence (here, a string) and executes one or more statements for each item. In effect, the variable c becomes a cursor stepping across the string’s characters here. We will discuss iteration tools like these and others listed in Table 7-1 in more detail later in this book (especially in Chap- ter 14 and Chapter 20). Indexing and Slicing Because strings are defined as ordered collections of characters, we can access their components by position. In Python, characters in a string are fetched by indexing— providing the numeric offset of the desired component in square brackets after the string. You get back the one-character string at the specified position. As in the C language, Python offsets start at 0 and end at one less than the length of the string. Unlike C, however, Python also lets you fetch items from sequences such as strings using negative offsets. Technically, a negative offset is added to the length of a string to derive a positive offset. You can also think of negative offsets as counting backward from the end. The following interaction demonstrates: >>> S = 'spam' >>> S[0], S[−2] # Indexing from front or end ('s', 'a') >>> S[1:3], S[1:], S[:−1] # Slicing: extract a section ('pa', 'pam', 'spa') The first line defines a four-character string and assigns it the name S. The next line indexes it in two ways: S[0] fetches the item at offset 0 from the left—the one-character string 's'; S[−2] gets the item at offset 2 back from the end—or equivalently, at offset (4 + (−2)) from the front. In more graphic terms, offsets and slices map to cells as shown in Figure 7-1.1 1. More mathematically minded readers (and students in my classes) sometimes detect a small asymmetry here: the leftmost item is at offset 0, but the rightmost is at offset −1. Alas, there is no such thing as a distinct −0 value in Python. Strings in Action | 201
- 254. The last line in the preceding example demonstrates slicing, a generalized form of in- dexing that returns an entire section, not a single item. Probably the best way to think of slicing is that it is a type of parsing (analyzing structure), especially when applied to strings—it allows us to extract an entire section (substring) in a single step. Slices can be used to extract columns of data, chop off leading and trailing text, and more. In fact, we’ll explore slicing in the context of text parsing later in this chapter. The basics of slicing are straightforward. When you index a sequence object such as a string on a pair of offsets separated by a colon, Python returns a new object containing the contiguous section identified by the offset pair. The left offset is taken to be the lower bound (inclusive), and the right is the upper bound (noninclusive). That is, Python fetches all items from the lower bound up to but not including the upper bound, and returns a new object containing the fetched items. If omitted, the left and right bounds default to 0 and the length of the object you are slicing, respectively. For instance, in the example we just saw, S[1:3] extracts the items at offsets 1 and 2: it grabs the second and third items, and stops before the fourth item at offset 3. Next, S[1:] gets all items beyond the first—the upper bound, which is not specified, defaults to the length of the string. Finally, S[:−1] fetches all but the last item—the lower bound defaults to 0, and −1 refers to the last item, noninclusive. This may seem confusing at first glance, but indexing and slicing are simple and pow- erful tools to use, once you get the knack. Remember, if you’re unsure about the effects of a slice, try it out interactively. In the next chapter, you’ll see that it’s even possible to change an entire section of another object in one step by assigning to a slice (though not for immutables like strings). Here’s a summary of the details for reference: Indexing (S[i]) fetches components at offsets: • The first item is at offset 0. • Negative indexes mean to count backward from the end or right. • S[0] fetches the first item. • S[−2] fetches the second item from the end (like S[len(S)−2]). Figure 7-1. Offsets and slices: positive offsets start from the left end (offset 0 is the first item), and negatives count back from the right end (offset −1 is the last item). Either kind of offset can be used to give positions in indexing and slicing operations. 202 | Chapter 7: String Fundamentals
- 255. Slicing (S[i:j]) extracts contiguous sections of sequences: • The upper bound is noninclusive. • Slice boundaries default to 0 and the sequence length, if omitted. • S[1:3] fetches items at offsets 1 up to but not including 3. • S[1:] fetches items at offset 1 through the end (the sequence length). • S[:3] fetches items at offset 0 up to but not including 3. • S[:−1] fetches items at offset 0 up to but not including the last item. • S[:] fetches items at offsets 0 through the end—making a top-level copy of S. Extended slicing (S[i:j:k]) accepts a step (or stride) k, which defaults to +1: • Allows for skipping items and reversing order—see the next section. The second-to-last bullet item listed here turns out to be a very common technique: it makes a full top-level copy of a sequence object—an object with the same value, but a distinct piece of memory (you’ll find more on copies in Chapter 9). This isn’t very useful forimmutableobjectslikestrings,butitcomesinhandyforobjectsthatmaybechanged in place, such as lists. In the next chapter, you’ll see that the syntax used to index by offset (square brackets) is used to index dictionaries by key as well; the operations look the same but have different interpretations. Extended slicing: The third limit and slice objects In Python 2.3 and later, slice expressions have support for an optional third index, used as a step (sometimes called a stride). The step is added to the index of each item ex- tracted. The full-blown form of a slice is now X[I:J:K], which means “extract all the items in X, from offset I through J−1, by K.” The third limit, K, defaults to +1, which is why normally all items in a slice are extracted from left to right. If you specify an explicit value, however, you can use the third limit to skip items or to reverse their order. For instance, X[1:10:2] will fetch every other item in X from offsets 1–9; that is, it will collect the items at offsets 1, 3, 5, 7, and 9. As usual, the first and second limits default to 0 and the length of the sequence, respectively, so X[::2] gets every other item from the beginning to the end of the sequence: >>> S = 'abcdefghijklmnop' >>> S[1:10:2] # Skipping items 'bdfhj' >>> S[::2] 'acegikmo' You can also use a negative stride to collect items in the opposite order. For example, the slicing expression "hello"[::−1] returns the new string "olleh"—the first two bounds default to 0 and the length of the sequence, as before, and a stride of−1 indicates that the slice should go from right to left instead of the usual left to right. The effect, therefore, is to reverse the sequence: Strings in Action | 203
- 256. >>> S = 'hello' >>> S[::−1] # Reversing items 'olleh' With a negative stride, the meanings of the first two bounds are essentially reversed. That is, the slice S[5:1:−1] fetches the items from 2 to 5, in reverse order (the result contains items from offsets 5, 4, 3, and 2): >>> S = 'abcedfg' >>> S[5:1:−1] # Bounds roles differ 'fdec' Skipping and reversing like this are the most common use cases for three-limit slices, but see Python’s standard library manual for more details (or run a few experiments interactively). We’ll revisit three-limit slices again later in this book, in conjunction with the for loop statement. Later in the book, we’ll also learn that slicing is equivalent to indexing with a slice object, a finding of importance to class writers seeking to support both operations: >>> 'spam'[1:3] # Slicing syntax 'pa' >>> 'spam'[slice(1, 3)] # Slice objects with index syntax + object 'pa' >>> 'spam'[::-1] 'maps' >>> 'spam'[slice(None, None, −1)] 'maps' Why You Will Care: Slices Throughout this book, I will include common use-case sidebars (such as this one) to give you a peek at how some of the language features being introduced are typically used in real programs. Because you won’t be able to make much sense of realistic use cases until you’ve seen more of the Python picture, these sidebars necessarily contain many references to topics not introduced yet; at most, you should consider them pre- views of ways that you may find these abstract language concepts useful for common programming tasks. For instance, you’ll see later that the argument words listed on a system command line used to launch a Python program are made available in the argv attribute of the built- in sys module: # File echo.py import sys print(sys.argv) % python echo.py −a −b −c ['echo.py', '−a', '−b', '−c'] Usually, you’re only interested in inspecting the arguments that follow the program name. This leads to a typical application of slices: a single slice expression can be used to return all but the first item of a list. Here, sys.argv[1:] returns the desired list, 204 | Chapter 7: String Fundamentals
- 257. ['−a', '−b', '−c']. You can then process this list without having to accommodate the program name at the front. Slices are also often used to clean up lines read from input files. If you know that a line will have an end-of-line character at the end (a n newline marker), you can get rid of it with a single expression such as line[:−1], which extracts all but the last character in the line (the lower limit defaults to 0). In both cases, slices do the job of logic that must be explicit in a lower-level language. Havingsaidthat,callingtheline.rstrip methodisoftenpreferredforstrippingnewline characters because this call leaves the line intact if it has no newline character at the end—a common case for files created with some text-editing tools. Slicing works if you’re sure the line is properly terminated. String Conversion Tools One of Python’s design mottos is that it refuses the temptation to guess. As a prime example, you cannot add a number and a string together in Python, even if the string looks like a number (i.e., is all digits): # Python 3.X >>> "42" + 1 TypeError: Can't convert 'int' object to str implicitly # Python 2.X >>> "42" + 1 TypeError: cannot concatenate 'str' and 'int' objects This is by design: because + can mean both addition and concatenation, the choice of conversion would be ambiguous. Instead, Python treats this as an error. In Python, magic is generally omitted if it will make your life more complex. What to do, then, if your script obtains a number as a text string from a file or user interface? The trick is that you need to employ conversion tools before you can treat a string like a number, or vice versa. For instance: >>> int("42"), str(42) # Convert from/to string (42, '42') >>> repr(42) # Convert to as-code string '42' The int function converts a string to a number, and the str function converts a number to its string representation (essentially, what it looks like when printed). The repr function (and the older backquotes expression, removed in Python 3.X) also converts an object to its string representation, but returns the object as a string of code that can be rerun to recreate the object. For strings, the result has quotes around it if displayed with a print statement, which differs in form between Python lines: >>> print(str('spam'), repr('spam')) # 2.X: print str('spam'), repr('spam') spam 'spam' Strings in Action | 205
- 258. >>> str('spam'), repr('spam') # Raw interactive echo displays ('spam', "'spam'") See the sidebar in Chapter 5’s “str and repr Display Formats” on page 144 for more on these topics. Of these, int and str are the generally prescribed to-number and to-string conversion techniques. Now, although you can’t mix strings and number types around operators such as +, you can manually convert operands before that operation if needed: >>> S = "42" >>> I = 1 >>> S + I TypeError: Can't convert 'int' object to str implicitly >>> int(S) + I # Force addition 43 >>> S + str(I) # Force concatenation '421' Similar built-in functions handle floating-point-number conversions to and from strings: >>> str(3.1415), float("1.5") ('3.1415', 1.5) >>> text = "1.234E-10" >>> float(text) # Shows more digits before 2.7 and 3.1 1.234e-10 Later, we’ll further study the built-in eval function; it runs a string containing Python expression code and so can convert a string to any kind of object. The functions int and float convert only to numbers, but this restriction means they are usually faster (and more secure, because they do not accept arbitrary expression code). As we saw briefly in Chapter 5, the string formatting expression also provides a way to convert numbers to strings. We’ll discuss formatting further later in this chapter. Character code conversions On the subject of conversions, it is also possible to convert a single character to its underlying integer code (e.g., its ASCII byte value) by passing it to the built-in ord function—this returns the actual binary value used to represent the corresponding characterinmemory.Thechr functionperformstheinverseoperation,takinganinteger code and converting it to the corresponding character: >>> ord('s') 115 >>> chr(115) 's' Technically, both of these convert characters to and from their Unicode ordinals or “code points,” which are just their identifying number in the underlying character set. 206 | Chapter 7: String Fundamentals
- 259. For ASCII text, this is the familiar 7-bit integer that fits in a single byte in memory, but the range of code points for other kinds of Unicode text may be wider (more on char- acter sets and Unicode in Chapter 37). You can use a loop to apply these functions to all characters in a string if required. These tools can also be used to perform a sort of string-based math. To advance to the next character, for example, convert and do the math in integer: >>> S = '5' >>> S = chr(ord(S) + 1) >>> S '6' >>> S = chr(ord(S) + 1) >>> S '7' At least for single-character strings, this provides an alternative to using the built-in int function to convert from string to integer (though this only makes sense in character sets that order items as your code expects!): >>> int('5') 5 >>> ord('5') - ord('0') 5 Such conversions can be used in conjunction with looping statements, introduced in Chapter 4 and covered in depth in the next part of this book, to convert a string of binarydigitstotheircorrespondingintegervalues.Eachtimethroughtheloop,multiply the current value by 2 and add the next digit’s integer value: >>> B = '1101' # Convert binary digits to integer with ord >>> I = 0 >>> while B != '': ... I = I * 2 + (ord(B[0]) - ord('0')) ... B = B[1:] ... >>> I 13 A left-shift operation (I << 1) would have the same effect as multiplying by 2 here. We’ll leave this change as a suggested exercise, though, both because we haven’t stud- ied loops in detail yet and because the int and bin built-ins we met in Chapter 5 handle binary conversion tasks for us as of Python 2.6 and 3.0: >>> int('1101', 2) # Convert binary to integer: built-in 13 >>> bin(13) # Convert integer to binary: built-in '0b1101' Given enough time, Python tends to automate most common tasks! Strings in Action | 207
- 260. Changing Strings I Remember the term “immutable sequence”? As we’ve seen, the immutable part means that you cannot change a string in place—for instance, by assigning to an index: >>> S = 'spam' >>> S[0] = 'x' # Raises an error! TypeError: 'str' object does not support item assignment How to modify text information in Python, then? To change a string, you generally need to build and assign a new string using tools such as concatenation and slicing, and then, if desired, assign the result back to the string’s original name: >>> S = S + 'SPAM!' # To change a string, make a new one >>> S 'spamSPAM!' >>> S = S[:4] + 'Burger' + S[−1] >>> S 'spamBurger!' The first example adds a substring at the end of S, by concatenation. Really, it makes a new string and assigns it back to S, but you can think of this as “changing” the original string. The second example replaces four characters with six by slicing, indexing, and concatenating. As you’ll see in the next section, you can achieve similar effects with string method calls like replace: >>> S = 'splot' >>> S = S.replace('pl', 'pamal') >>> S 'spamalot' Like every operation that yields a new string value, string methods generate new string objects. If you want to retain those objects, you can assign them to variable names. Generating a new string object for each string change is not as inefficient as it may sound—remember, as discussed in the preceding chapter, Python automatically garbage-collects (reclaims the space of) old unused string objects as you go, so newer objects reuse the space held by prior values. Python is usually more efficient than you might expect. Finally, it’s also possible to build up new text values with string formatting expressions. Both of the following substitute objects into a string, in a sense converting the objects to strings and changing the original string according to a format specification: >>> 'That is %d %s bird!' % (1, 'dead') # Format expression: all Pythons That is 1 dead bird! >>> 'That is {0} {1} bird!'.format(1, 'dead') # Format method in 2.6, 2.7, 3.X 'That is 1 dead bird!' Despite the substitution metaphor, though, the result of formatting is a new string object, not a modified one. We’ll study formatting later in this chapter; as we’ll find, formatting turns out to be more general and useful than this example implies. Because 208 | Chapter 7: String Fundamentals
- 261. the second of the preceding calls is provided as a method, though, let’s get a handle on string method calls before we explore formatting further. As previewed in Chapter 4 and to be covered in Chapter 37, Python 3.0 and 2.6 introduced a new string type known as bytearray, which is mu- table and so may be changed in place. bytearray objects aren’t really text strings; they’re sequences of small, 8-bit integers. However, they support most of the same operations as normal strings and print as AS- CII characters when displayed. Accordingly, they provide another op- tion for large amounts of simple 8-bit text that must be changed fre- quently (richer types of Unicode text imply different techniques). In Chapter 37 we’ll also see that ord and chr handle Unicode characters, too, which might not be stored in single bytes. String Methods In addition to expression operators, strings provide a set of methods that implement more sophisticated text-processing tasks. In Python, expressions and built-in functions may work across a range of types, but methods are generally specific to object types— string methods, for example, work only on string objects. The method sets of some types intersect in Python 3.X (e.g., many types have count and copy methods), but they are still more type-specific than other tools. Method Call Syntax As introduced in Chapter 4, methods are simply functions that are associated with and act upon particular objects. Technically, they are attributes attached to objects that happen to reference callable functions which always have an implied subject. In finer- grained detail, functions are packages of code, and method calls combine two opera- tions at once—an attribute fetch and a call: Attribute fetches An expression of the form object.attribute means “fetch the value of attribute in object.” Call expressions An expression of the form function(arguments) means “invoke the code of func tion, passing zero or more comma-separated argument objects to it, and return function’s result value.” Putting these two together allows us to call a method of an object. The method call expression: object.method(arguments) String Methods | 209
- 262. is evaluated from left to right—Python will first fetch the method of the object and then call it, passing in both object and the arguments. Or, in plain words, the method call expression means this: Call method to process object with arguments. If the method computes a result, it will also come back as the result of the entire method- call expression. As a more tangible example: >>> S = 'spam' >>> result = S.find('pa') # Call the find method to look for 'pa' in string S This mapping holds true for methods of both built-in types, as well as user-defined classes we’ll study later. As you’ll see throughout this part of the book, most objects have callable methods, and all are accessed using this same method-call syntax. To call an object method, as you’ll see in the following sections, you have to go through an existing object; methods cannot be run (and make little sense) without a subject. Methods of Strings Table 7-3 summarizes the methods and call patterns for built-in string objects in Python 3.3; these change frequently, so be sure to check Python’s standard library manual for the most up-to-date list, or run a dir or help call on any string (or the str type name) interactively. Python 2.X’s string methods vary slightly; it includes a decode, for exam- ple, because of its different handling of Unicode data (something we’ll discuss in Chapter 37). In this table, S is a string object, and optional arguments are enclosed in square brackets. String methods in this table implement higher-level operations such as splitting and joining, case conversions, content tests, and substring searches and replacements. Table 7-3. String method calls in Python 3.3 S.capitalize() S.ljust(width [, fill]) S.casefold() S.lower() S.center(width [, fill]) S.lstrip([chars]) S.count(sub [, start [, end]]) S.maketrans(x[, y[, z]]) S.encode([encoding [,errors]]) S.partition(sep) S.endswith(suffix [, start [, end]]) S.replace(old, new [, count]) S.expandtabs([tabsize]) S.rfind(sub [,start [,end]]) S.find(sub [, start [, end]]) S.rindex(sub [, start [, end]]) S.format(fmtstr, *args, **kwargs) S.rjust(width [, fill]) S.index(sub [, start [, end]]) S.rpartition(sep) S.isalnum() S.rsplit([sep[, maxsplit]]) S.isalpha() S.rstrip([chars]) S.isdecimal() S.split([sep [,maxsplit]]) 210 | Chapter 7: String Fundamentals
- 263. S.isdigit() S.splitlines([keepends]) S.isidentifier() S.startswith(prefix [, start [, end]]) S.islower() S.strip([chars]) S.isnumeric() S.swapcase() S.isprintable() S.title() S.isspace() S.translate(map) S.istitle() S.upper() S.isupper() S.zfill(width) S.join(iterable) As you can see, there are quite a few string methods, and we don’t have space to cover them all; see Python’s library manual or reference texts for all the fine points. To help you get started, though, let’s work through some code that demonstrates some of the most commonly used methods in action, and illustrates Python text-processing basics along the way. String Method Examples: Changing Strings II As we’ve seen, because strings are immutable, they cannot be changed in place directly. The bytearray supports in-place text changes in 2.6, 3.0, and later, but only for simple 8-bit types. We explored changes to text strings earlier, but let’s take a quick second look here in the context of string methods. In general, to make a new text value from an existing string, you construct a new string with operations such as slicing and concatenation. For example, to replace two char- acters in the middle of a string, you can use code like this: >>> S = 'spammy' >>> S = S[:3] + 'xx' + S[5:] # Slice sections from S >>> S 'spaxxy' But, if you’re really just out to replace a substring, you can use the stringreplace method instead: >>> S = 'spammy' >>> S = S.replace('mm', 'xx') # Replace all mm with xx in S >>> S 'spaxxy' The replace method is more general than this code implies. It takes as arguments the original substring (of any length) and the string (of any length) to replace it with, and performs a global search and replace: >>> 'aa$bb$cc$dd'.replace('$', 'SPAM') 'aaSPAMbbSPAMccSPAMdd' String Methods | 211
- 264. In such a role, replace can be used as a tool to implement template replacements (e.g., in form letters). Notice that this time we simply printed the result, instead of assigning it to a name—you need to assign results to names only if you want to retain them for later use. If you need to replace one fixed-size string that can occur at any offset, you can do a replacement again, or search for the substring with the string find method and then slice: >>> S = 'xxxxSPAMxxxxSPAMxxxx' >>> where = S.find('SPAM') # Search for position >>> where # Occurs at offset 4 4 >>> S = S[:where] + 'EGGS' + S[(where+4):] >>> S 'xxxxEGGSxxxxSPAMxxxx' The find method returns the offset where the substring appears (by default, searching fromthefront),or−1 ifitis notfound.Aswesaw earlier, it’sasubstringsearchoperation just like the in expression, but find returns the position of a located substring. Anotheroptionis tousereplace withathirdargumentto limitittoasinglesubstitution: >>> S = 'xxxxSPAMxxxxSPAMxxxx' >>> S.replace('SPAM', 'EGGS') # Replace all 'xxxxEGGSxxxxEGGSxxxx' >>> S.replace('SPAM', 'EGGS', 1) # Replace one 'xxxxEGGSxxxxSPAMxxxx' Notice that replace returns a new string object each time. Because strings are immut- able, methods never really change the subject strings in place, even if they are called “replace”! The fact that concatenation operations and the replace method generate new string objects each time they are run is actually a potential downside of using them to change strings. If you have to apply many changes to a very large string, you might be able to improve your script’s performance by converting the string to an object that does sup- port in-place changes: >>> S = 'spammy' >>> L = list(S) >>> L ['s', 'p', 'a', 'm', 'm', 'y'] The built-in list function (an object construction call) builds a new list out of the items in any sequence—in this case, “exploding” the characters of a string into a list. Once the string is in this form, you can make multiple changes to it without generating a new copy for each change: >>> L[3] = 'x' # Works for lists, not strings >>> L[4] = 'x' 212 | Chapter 7: String Fundamentals
- 265. >>> L ['s', 'p', 'a', 'x', 'x', 'y'] If, after your changes, you need to convert back to a string (e.g., to write to a file), use the string join method to “implode” the list back into a string: >>> S = ''.join(L) >>> S 'spaxxy' The join method may look a bit backward at first sight. Because it is a method of strings (not of lists), it is called through the desired delimiter. join puts the strings in a list (or other iterable) together, with the delimiter between list items; in this case, it uses an empty string delimiter to convert from a list back to a string. More generally, any string delimiter and iterable of strings will do: >>> 'SPAM'.join(['eggs', 'sausage', 'ham', 'toast']) 'eggsSPAMsausageSPAMhamSPAMtoast' In fact, joining substrings all at once might often run faster than concatenating them individually. Be sure to also see the earlier note about the mutable bytearray string available as of Python 3.0 and 2.6, described fully in Chapter 37; because it may be changed in place, it offers an alternative to this list/join combination for some kinds of 8-bit text that must be changed often. String Method Examples: Parsing Text Another common role for string methods is as a simple form of text parsing—that is, analyzing structure and extracting substrings. To extract substrings at fixed offsets, we can employ slicing techniques: >>> line = 'aaa bbb ccc' >>> col1 = line[0:3] >>> col3 = line[8:] >>> col1 'aaa' >>> col3 'ccc' Here, the columns of data appear at fixed offsets and so may be sliced out of the original string. This technique passes for parsing, as long as the components of your data have fixed positions. If instead some sort of delimiter separates the data, you can pull out its components by splitting. This will work even if the data may show up at arbitrary positions within the string: >>> line = 'aaa bbb ccc' >>> cols = line.split() >>> cols ['aaa', 'bbb', 'ccc'] The string split method chops up a string into a list of substrings, around a delimiter string. We didn’t pass a delimiter in the prior example, so it defaults to whitespace— String Methods | 213
- 266. the string is split at groups of one or more spaces, tabs, and newlines, and we get back a list of the resulting substrings. In other applications, more tangible delimiters may separate the data. This example splits (and hence parses) the string at commas, a sep- arator common in data returned by some database tools: >>> line = 'bob,hacker,40' >>> line.split(',') ['bob', 'hacker', '40'] Delimiters can be longer than a single character, too: >>> line = "i'mSPAMaSPAMlumberjack" >>> line.split("SPAM") ["i'm", 'a', 'lumberjack'] Although there are limits to the parsing potential of slicing and splitting, both run very fast and can handle basic text-extraction chores. Comma-separated text data is part of the CSV file format; for more advanced tools on this front, see also the csv module in Python’s standard library. Other Common String Methods in Action Other string methods have more focused roles—for example, to strip off whitespace attheendofalineoftext,performcaseconversions,testcontent,andtestforasubstring at the end or front: >>> line = "The knights who say Ni!n" >>> line.rstrip() 'The knights who say Ni!' >>> line.upper() 'THE KNIGHTS WHO SAY NI!n' >>> line.isalpha() False >>> line.endswith('Ni!n') True >>> line.startswith('The') True Alternative techniques can also sometimes be used to achieve the same results as string methods—the in membership operator can be used to test for the presence of a sub- string, for instance, and length and slicing operations can be used to mimic endswith: >>> line 'The knights who say Ni!n' >>> line.find('Ni') != −1 # Search via method call or expression True >>> 'Ni' in line True >>> sub = 'Ni!n' >>> line.endswith(sub) # End test via method call or slice True 214 | Chapter 7: String Fundamentals
- 267. >>> line[-len(sub):] == sub True See also the format string formatting method described later in this chapter; it provides more advanced substitution tools that combine many operations in a single step. Again, because there are so many methods available for strings, we won’t look at every one here. You’ll see some additional string examples later in this book, but for more details you can also turn to the Python library manual and other documentation sour- ces, or simply experiment interactively on your own. You can also check the help(S.method) results for a method of any string object S for more hints; as we saw in Chapter 4, running help on str.method likely gives the same details. Note that none of the string methods accepts patterns—for pattern-based text pro- cessing, you must use the Python re standard library module, an advanced tool that was introduced in Chapter 4 but is mostly outside the scope of this text (one further brief example appears at the end of Chapter 37). Because of this limitation, though, string methods may sometimes run more quickly than the re module’s tools. The Original string Module’s Functions (Gone in 3.X) The history of Python’s string methods is somewhat convoluted. For roughly the first decade of its existence, Python provided a standard library module called string that contained functions that largely mirrored the current set of string object methods. By popular demand, in Python 2.0 these functions were made available as methods of string objects. Because so many people had written so much code that relied on the original string module, however, it was retained for backward compatibility. Today, you should use only string methods, not the original string module. In fact, the original module call forms of today’s string methods have been removed completely from Python 3.X, and you should not use them in new code in either 2.X or 3.X. How- ever, because you may still see the module in use in older Python 2.X code, and this text covers both Pythons 2.X and 3.X, a brief look is in order here. The upshot of this legacy is that in Python 2.X, there technically are still two ways to invoke advanced string operations: by calling object methods, or by calling string module functions and passing in the objects as arguments. For instance, given a variable X assigned to a string object, calling an object method: X.method(arguments) is usually equivalent to calling the same operation through thestring module (provided that you have already imported the module): string.method(X, arguments) Here’s an example of the method scheme in action: >>> S = 'a+b+c+' >>> x = S.replace('+', 'spam') String Methods | 215
- 268. >>> x 'aspambspamcspam' To access the same operation through the string module in Python 2.X, you need to import the module (at least once in your process) and pass in the object: >>> import string >>> y = string.replace(S, '+', 'spam') >>> y 'aspambspamcspam' Because the module approach was the standard for so long, and because strings are such a central component of most programs, you might see both call patterns in Python 2.X code you come across. Again, though, today you should always use method calls instead of the older module calls. There are good reasons for this, besides the fact that the module calls have gone away in 3.X. For one thing, the module call scheme requires you to import the string module (methods do not require imports). For another, the module makes calls a few characters longer to type (when you load the module with import, that is, not using from). And, finally, the module runs more slowly than methods (the module maps most calls back to the methods and so incurs an extra call along the way). The original string module itself, without its string method equivalents, is retained in Python 3.X because it contains additional tools, including predefined string constants (e.g., string.digits) and a Template object system—a relatively obscure formatting tool that predates the string format method and is largely omitted here (for details, see the brief note comparing it to other formatting tools ahead, as well as Python’s library manual). Unless you really want to have to change your 2.X code to use 3.X, though, you should consider any basic string operation calls in it to be just ghosts of Pythonpast. String Formatting Expressions Although you can get a lot done with the string methods and sequence operations we’ve already met, Python also provides a more advanced way to combine string processing tasks—string formatting allows us to perform multiple type-specific substitutions on a string in a single step. It’s never strictly required, but it can be convenient, especially when formatting text to be displayed to a program’s users. Due to the wealth of new ideas in the Python world, string formatting is available in two flavors in Python today (not counting the less-used string module Template system mentioned in the prior section): String formatting expressions: '...%s...' % (values) The original technique available since Python’s inception, this form is based upon the C language’s “printf” model, and sees widespread use in much existing code. 216 | Chapter 7: String Fundamentals
- 269. String formatting method calls: '...{}...'.format(values) A newer technique added in Python 2.6 and 3.0, this form is derived in part from a same-named tool in C#/.NET, and overlaps with string formatting expression functionality. Since the method call flavor is newer, there is some chance that one or the other of these may become deprecated and removed over time. When 3.0 was released in 2008, the expression seemed more likely to be deprecated in later Python releases. Indeed, 3.0’s documentation threatened deprecation in 3.1 and removal thereafter. This hasn’t hap- pened as of 2013 and 3.3, and now looks unlikely given the expression’s wide use—in fact, it still appears even in Python’s own standard library thousands of times today! Naturally, this story’s development depends on the future practice of Python’s users. On the other hand, because both the expression and method are valid to use today and either may appear in code you’ll come across, this book covers both techniques in full here. As you’ll see, the two are largely variations on a theme, though the method has some extra features (such as thousands separators), and the expression is often more concise and seems second nature to most Python programmers. This book itself uses both techniques in later examples for illustrative purposes. If its author has a preference, he will keep it largely classified, except to quote from Python’s import this motto: There should be one—and preferably only one—obvious way to do it. Unless the newer string formatting method is compellingly better than the original and widely used expression, its doubling of Python programmers’ knowledge base require- ments in this domain seems unwarranted—and even un-Pythonic, per the original and longstanding meaning of that term. Programmers should not have to learn two com- plicated tools if those tools largely overlap. You’ll have to judge for yourself whether formatting merits the added language heft, of course, so let’s give both a fair hearing. Formatting Expression Basics Since string formatting expressions are the original in this department, we’ll start with them. Python defines the % binary operator to work on strings (you may recall that this is also the remainder of division, or modulus, operator for numbers). When applied to strings, the % operator provides a simple way to format values as strings according to a format definition. In short, the % operator provides a compact way to code multiple stringsubstitutionsallatonce,insteadofbuildingandconcatenatingpartsindividually. To format strings: 1. On the left of the % operator, provide a format string containing one or more em- bedded conversion targets, each of which starts with a % (e.g., %d). String Formatting Expressions | 217
- 270. 2. On the right of the % operator, provide the object (or objects, embedded in a tuple) that you want Python to insert into the format string on the left in place of the conversion target (or targets). For instance, in the formatting example we saw earlier in this chapter, the integer 1 replaces the %d in the format string on the left, and the string 'dead' replaces the %s. The result is a new string that reflects these two substitutions, which may be printed or saved for use in other roles: >>> 'That is %d %s bird!' % (1, 'dead') # Format expression That is 1 dead bird! Technically speaking, string formatting expressions are usually optional—you can generally do similar work with multiple concatenations and conversions. However, formatting allows us to combine many steps into a single operation. It’s powerful enough to warrant a few more examples: >>> exclamation = 'Ni' >>> 'The knights who say %s!' % exclamation # String substitution 'The knights who say Ni!' >>> '%d %s %g you' % (1, 'spam', 4.0) # Type-specific substitutions '1 spam 4 you' >>> '%s -- %s -- %s' % (42, 3.14159, [1, 2, 3]) # All types match a %s target '42 -- 3.14159 -- [1, 2, 3]' The first example here plugs the string 'Ni' into the target on the left, replacing the %s marker. In the second example, three values are inserted into the target string. Note that when you’re inserting more than one value, you need to group the values on the right in parentheses (i.e., put them in a tuple). The % formatting expression operator expects either a single item or a tuple of one or more items on its right side. The third example again inserts three values—an integer, a floating-point object, and a list object—but notice that all of the targets on the left are %s, which stands for con- version to string. As every type of object can be converted to a string (the one used when printing), every object type works with the %s conversion code. Because of this, unless you will be doing some special formatting, %s is often the only code you need to remember for the formatting expression. Again, keep in mind that formatting always makes a new string, rather than changing the string on the left; because strings are immutable, it must work this way. As before, assign the result to a variable name if you need to retain it. Advanced Formatting Expression Syntax For more advanced type-specific formatting, you can use any of the conversion type codes listed in Table 7-4 in formatting expressions; they appear after the % character in substitution targets. C programmers will recognize most of these because Python string formatting supports all the usual C printf format codes (but returns the result, instead 218 | Chapter 7: String Fundamentals
- 271. of displaying it, like printf). Some of the format codes in the table provide alternative ways to format the same type; for instance, %e, %f, and %g provide alternative ways to format floating-point numbers. Table 7-4. String formatting type codes Code Meaning s String (or any object’s str(X) string) r Same as s, but uses repr, not str c Character (int or str) d Decimal (base-10 integer) i Integer u Same as d (obsolete: no longer unsigned) o Octal integer (base 8) x Hex integer (base 16) X Same as x, but with uppercase letters e Floating point with exponent, lowercase E Same as e, but uses uppercase letters f Floating-point decimal F Same as f, but uses uppercase letters g Floating-point e or f G Floating-point E or F % Literal % (coded as %%) In fact, conversion targets in the format string on the expression’s left side support a variety of conversion operations with a fairly sophisticated syntax all their own. The general structure of conversion targets looks like this: %[(keyname)][flags][width][.precision]typecode The type code characters in the first column of Table 7-4 show up at the end of this target string’s format. Between the % and the type code character, you can do any of the following: • Provide a key name for indexing the dictionary used on the right side of the ex- pression • Listflagsthatspecifythingslikeleftjustification(−),numericsign(+),ablankbefore positive numbers and a – for negatives (a space), and zero fills (0) • Give a total minimum field width for the substituted text • Set the number of digits (precision) to display after a decimal point for floating- point numbers String Formatting Expressions | 219
- 272. Both the width and precision parts can also be coded as a * to specify that they should take their values from the next item in the input values on the expression’s right side (useful when this isn’t known until runtime). And if you don’t need any of these extra tools, a simple %s in the format string will be replaced by the corresponding value’s default print string, regardless of its type. Advanced Formatting Expression Examples Formatting target syntax is documented in full in the Python standard manuals and reference texts, but to demonstrate common usage, let’s look at a few examples. This one formats integers by default, and then in a six-character field with left justification and zero padding: >>> x = 1234 >>> res = 'integers: ...%d...%−6d...%06d' % (x, x, x) >>> res 'integers: ...1234...1234 ...001234' The %e, %f, and %g formats display floating-point numbers in different ways, as the following interaction demonstrates—%E is the same as%e but the exponent is uppercase, and g chooses formats by number content (it’s formally defined to use exponential format e if the exponent is less than −4 or not less than precision, and decimal format f otherwise, with a default total digits precision of 6): >>> x = 1.23456789 >>> x # Shows more digits before 2.7 and 3.1 1.23456789 >>> '%e | %f | %g' % (x, x, x) '1.234568e+00 | 1.234568 | 1.23457' >>> '%E' % x '1.234568E+00' For floating-point numbers, you can achieve a variety of additional formatting effects by specifying left justification, zero padding, numeric signs, total field width, and digits after the decimal point. For simpler tasks, you might get by with simply converting to strings with a %s format expression or the str built-in function shown earlier: >>> '%−6.2f | %05.2f | %+06.1f' % (x, x, x) '1.23 | 01.23 | +001.2' >>> '%s' % x, str(x) ('1.23456789', '1.23456789') When sizes are not known until runtime, you can use a computed width and precision by specifying them with a * in the format string to force their values to be taken from the next item in the inputs to the right of the % operator—the 4 in the tuple here gives precision: >>> '%f, %.2f, %.*f' % (1/3.0, 1/3.0, 4, 1/3.0) '0.333333, 0.33, 0.3333' 220 | Chapter 7: String Fundamentals
- 273. If you’re interested in this feature, experiment with some of these examples and oper- ations on your own for more insight. Dictionary-Based Formatting Expressions As a more advanced extension, string formatting also allows conversion targets on the left to refer to the keys in a dictionary coded on the right and fetch the corresponding values. This opens the door to using formatting as a sort of template tool. We’ve only met dictionaries briefly thus far in Chapter 4, but here’s an example that demonstrates the basics: >>> '%(qty)d more %(food)s' % {'qty': 1, 'food': 'spam'} '1 more spam' Here, the (qty) and (food) in the format string on the left refer to keys in the dictionary literal on the right and fetch their associated values. Programs that generate text such as HTML or XML often use this technique—you can build up a dictionary of values and substitute them all at once with a single formatting expression that uses key-based references (notice the first comment is above the triple quote so it’s not added to the string, and I’m typing this in IDLE without a “...” prompt for continuation lines): >>> # Template with substitution targets >>> reply = """ Greetings... Hello %(name)s! Your age is %(age)s """ >>> values = {'name': 'Bob', 'age': 40} # Build up values to substitute >>> print(reply % values) # Perform substitutions Greetings... Hello Bob! Your age is 40 This trick is also used in conjunction with the vars built-in function, which returns a dictionary containing all the variables that exist in the place it is called: >>> food = 'spam' >>> qty = 10 >>> vars() {'food': 'spam', 'qty': 10, ...plus built-in names set by Python... } When used on the right side of a format operation, this allows the format string to refer to variables by name—as dictionary keys: >>> '%(qty)d more %(food)s' % vars() # Variables are keys in vars() '10 more spam' We’ll study dictionaries in more depth in Chapter 8. See also Chapter 5 for examples that convert to hexadecimal and octal number strings with the %x and %o formatting expression target codes, which we won’t repeat here. Additional formatting expression String Formatting Expressions | 221
- 274. examples also appear ahead as comparisons to the formatting method—this chapter’s next and final string topic. String Formatting Method Calls As mentioned earlier, Python 2.6 and 3.0 introduced a new way to format strings that isseenbysomeasabitmorePython-specific.Unlikeformattingexpressions,formatting method calls are not closely based upon the C language’s “printf” model, and are sometimes more explicit in intent. On the other hand, the new technique still relies on core “printf” concepts, such as type codes and formatting specifications. Moreover, it largely overlaps with—and sometimes requires a bit more code than—formatting ex- pressions, and in practice can be just as complex in many roles. Because of this, there is no best-use recommendation between expressions and method calls today, and most programmers would be well served by a cursory understanding of both schemes. Luck- ily, the two are similar enough that many core concepts overlap. Formatting Method Basics The string object’s format method, available in Python 2.6, 2.7, and 3.X, is based on normal function call syntax, instead of an expression. Specifically, it uses the subject string as a template, and takes any number of arguments that represent values to be substituted according to the template. Its use requires knowledge of functions and calls, but is mostly straightforward. Within the subject string, curly braces designate substitution targets and arguments to be in- serted either by position (e.g., {1}), or keyword (e.g., {food}), or relative position in 2.7, 3.1, and later ({}). As we’ll learn when we study argument passing in depth in Chapter18,argumentstofunctionsandmethodsmaybepassedbypositionorkeyword name, and Python’s ability to collect arbitrarily many positional and keyword argu- ments allows for such general method call patterns. For example: >>> template = '{0}, {1} and {2}' # By position >>> template.format('spam', 'ham', 'eggs') 'spam, ham and eggs' >>> template = '{motto}, {pork} and {food}' # By keyword >>> template.format(motto='spam', pork='ham', food='eggs') 'spam, ham and eggs' >>> template = '{motto}, {0} and {food}' # By both >>> template.format('ham', motto='spam', food='eggs') 'spam, ham and eggs' >>> template = '{}, {} and {}' # By relative position >>> template.format('spam', 'ham', 'eggs') # New in 3.1 and 2.7 'spam, ham and eggs' 222 | Chapter 7: String Fundamentals
- 275. By comparison, the last section’s formatting expression can be a bit more concise, but uses dictionaries instead of keyword arguments, and doesn’t allow quite as much flex- ibility for value sources (which may be an asset or liability, depending on your per- spective); more on how the two techniques compare ahead: >>> template = '%s, %s and %s' # Same via expression >>> template % ('spam', 'ham', 'eggs') 'spam, ham and eggs' >>> template = '%(motto)s, %(pork)s and %(food)s' >>> template % dict(motto='spam', pork='ham', food='eggs') 'spam, ham and eggs' Note the use of dict() to make a dictionary from keyword arguments here, introduced in Chapter 4 and covered in full in Chapter 8; it’s an often less-cluttered alternative to the {...} literal. Naturally, the subject string in the format method call can also be a literal that creates a temporary string, and arbitrary object types can be substituted at targets much like the expression’s %s code: >>> '{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2]) '3.14, 42 and [1, 2]' Just as with the % expression and other string methods, format creates and returns a new string object, which can be printed immediately or saved for further work (recall that strings are immutable, so format really must make a new object). String formatting is not just for display: >>> X = '{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2]) >>> X '3.14, 42 and [1, 2]' >>> X.split(' and ') ['3.14, 42', '[1, 2]'] >>> Y = X.replace('and', 'but under no circumstances') >>> Y '3.14, 42 but under no circumstances [1, 2]' Adding Keys, Attributes, and Offsets Like % formatting expressions, format calls can become more complex to support more advanced usage. For instance, format strings can name object attributes and dictionary keys—as in normal Python syntax, square brackets name dictionary keys and dots denote object attributes of an item referenced by position or keyword. The first of the following examples indexes a dictionary on the key “spam” and then fetches the at- tribute “platform” from the already imported sys module object. The second does the same, but names the objects by keyword instead of position: >>> import sys >>> 'My {1[kind]} runs {0.platform}'.format(sys, {'kind': 'laptop'}) 'My laptop runs win32' String Formatting Method Calls | 223
- 276. >>> 'My {map[kind]} runs {sys.platform}'.format(sys=sys, map={'kind': 'laptop'}) 'My laptop runs win32' Square brackets in format strings can name list (and other sequence) offsets to perform indexing, too, but only single positive offsets work syntactically within format strings, so this feature is not as general as you might think. As with % expressions, to name negative offsets or slices, or to use arbitrary expression results in general, you must run expressions outside the format string itself (note the use of *parts here to unpack a tuple’s items into individual function arguments, as we did in Chapter 5 when studying fractions; more on this form in Chapter 18): >>> somelist = list('SPAM') >>> somelist ['S', 'P', 'A', 'M'] >>> 'first={0[0]}, third={0[2]}'.format(somelist) 'first=S, third=A' >>> 'first={0}, last={1}'.format(somelist[0], somelist[-1]) # [-1] fails in fmt 'first=S, last=M' >>> parts = somelist[0], somelist[-1], somelist[1:3] # [1:3] fails in fmt >>> 'first={0}, last={1}, middle={2}'.format(*parts) # Or '{}' in 2.7/3.1+ "first=S, last=M, middle=['P', 'A']" Advanced Formatting Method Syntax Another similarity with % expressions is that you can achieve more specific layouts by adding extra syntax in the format string. For the formatting method, we use a colon after the possibly empty substitution target’s identification, followed by a format speci- fier that can name the field size, justification, and a specific type code. Here’s the formal structure of what can appear as a substitution target in a format string—its four parts are all optional, and must appear without intervening spaces: {fieldname component !conversionflag :formatspec} In this substitution target syntax: • fieldname is an optional number or keyword identifying an argument, which may be omitted to use relative argument numbering in 2.7, 3.1, and later. • component is a string of zero or more “.name” or “[index]” references used to fetch attributes and indexed values of the argument, which may be omitted to use the whole argument value. • conversionflag starts with a ! if present, which is followed by r, s, or a to call repr, str, or ascii built-in functions on the value, respectively. • formatspec starts with a : if present, which is followed by text that specifies how the value should be presented, including details such as field width, alignment, padding, decimal precision, and so on, and ends with an optional data type code. 224 | Chapter 7: String Fundamentals
- 277. The formatspec component after the colon character has a rich format all its own, and is formally described as follows (brackets denote optional components and are not coded literally): [[fill]align][sign][#][0][width][,][.precision][typecode] In this, fill can be any fill character other than { or }; align may be <, >, =, or ^, for left alignment, right alignment, padding after a sign character, or centered alignment, respectively; sign may be +, −, or space; and the , (comma) option requests a comma for a thousands separator as of Python 2.7 and 3.1. width and precision are much as in the % expression, and the formatspec may also contain nested {} format strings with field names only, to take values from the arguments list dynamically (much like the * in formatting expressions). The method’s typecode options almost completely overlap with those used in % ex- pressions and listed previously in Table 7-4, but the format method also allows a b type code used to display integers in binary format (it’s equivalent to using the bin built-in call), allows a % type code to display percentages, and uses only d for base-10 integers (i or u are not used here). Note that unlike the expression’s %s, the s type code here requires a string object argument; omit the type code to accept any type generically. See Python’s library manual for more on substitution syntax that we’ll omit here. In addition to the string’s format method, a single object may also be formatted with the format(object, formatspec) built-in function (which the method uses internally), and may be customized in user-defined classes with the __format__ operator-overloading method (see Part VI). Advanced Formatting Method Examples As you can tell, the syntax can be complex in formatting methods. Because your best ally in such cases is often the interactive prompt here, let’s turn to some examples. In the following, {0:10} means the first positional argument in a field 10 characters wide, {1:<10} means the second positional argument left-justified in a 10-character-wide field, and {0.platform:>10} means the platform attribute of the first argument right- justified in a 10-character-wide field (note again the use of dict() to make a dictionary from keyword arguments, covered in Chapter 4 and Chapter 8): >>> '{0:10} = {1:10}'.format('spam', 123.4567) # In Python 3.3 'spam = 123.4567' >>> '{0:>10} = {1:<10}'.format('spam', 123.4567) ' spam = 123.4567 ' >>> '{0.platform:>10} = {1[kind]:<10}'.format(sys, dict(kind='laptop')) ' win32 = laptop ' In all cases, you can omit the argument number as of Python 2.7 and 3.1 if you’re selecting them from left to right with relative autonumbering—though this makes your String Formatting Method Calls | 225
- 278. code less explicit, thereby negating one of the reported advantages of the formatting method over the formatting expression (see the related note ahead): >>> '{:10} = {:10}'.format('spam', 123.4567) 'spam = 123.4567' >>> '{:>10} = {:<10}'.format('spam', 123.4567) ' spam = 123.4567 ' >>> '{.platform:>10} = {[kind]:<10}'.format(sys, dict(kind='laptop')) ' win32 = laptop ' Floating-point numbers support the same type codes and formatting specificity in for- matting method calls as in % expressions. For instance, in the following {2:g} means the third argument formatted by default according to the “g” floating-point represen- tation, {1:.2f} designates the “f” floating-point format with just two decimal digits, and {2:06.2f} adds a field with a width of six characters and zero padding on the left: >>> '{0:e}, {1:.3e}, {2:g}'.format(3.14159, 3.14159, 3.14159) '3.141590e+00, 3.142e+00, 3.14159' >>> '{0:f}, {1:.2f}, {2:06.2f}'.format(3.14159, 3.14159, 3.14159) '3.141590, 3.14, 003.14' Hex, octal, and binary formats are supported by the format method as well. In fact, string formatting is an alternative to some of the built-in functions that format integers to a given base: >>> '{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # Hex, octal, binary 'FF, 377, 11111111' >>> bin(255), int('11111111', 2), 0b11111111 # Other to/from binary ('0b11111111', 255, 255) >>> hex(255), int('FF', 16), 0xFF # Other to/from hex ('0xff', 255, 255) >>> oct(255), int('377', 8), 0o377 # Other to/from octal, in 3.X ('0o377', 255, 255) # 2.X prints and accepts 0377 Formatting parameters can either be hardcoded in format strings or taken from the arguments list dynamically by nested format syntax, much like the * syntax in format- ting expressions’ width and precision: >>> '{0:.2f}'.format(1 / 3.0) # Parameters hardcoded '0.33' >>> '%.2f' % (1 / 3.0) # Ditto for expression '0.33' >>> '{0:.{1}f}'.format(1 / 3.0, 4) # Take value from arguments '0.3333' >>> '%.*f' % (4, 1 / 3.0) # Ditto for expression '0.3333' 226 | Chapter 7: String Fundamentals
- 279. Finally, Python 2.6 and 3.0 also introduced a new built-in format function, which can be used to format a single item. It’s a more concise alternative to the string format method, and is roughly similar to formatting a single item with the % formatting ex- pression: >>> '{0:.2f}'.format(1.2345) # String method '1.23' >>> format(1.2345, '.2f') # Built-in function '1.23' >>> '%.2f' % 1.2345 # Expression '1.23' Technically, the format built-in runs the subject object’s __format__ method, which the str.format method does internally for each formatted item. It’s still more verbose than the original % expression’s equivalent here, though—which leads us to the next section. Comparison to the % Formatting Expression If you study the prior sections closely, you’ll probably notice that at least for positional references and dictionary keys, the string format method looks very much like the % formatting expression, especially in advanced use with type codes and extra formatting syntax. In fact, in common use cases formatting expressions may be easier to code than formatting method calls, especially when you’re using the generic %s print-string sub- stitution target, and even with autonumbering of fields added in 2.7 and 3.1: print('%s=%s' % ('spam', 42)) # Format expression: in all 2.X/3.X print('{0}={1}'.format('spam', 42)) # Format method: in 3.0+ and 2.6+ print('{}={}'.format('spam', 42)) # With autonumbering: in 3.1+ and 2.7 As we’ll see in a moment, more complex formatting tends to be a draw in terms of complexity (difficult tasks are generally difficult, regardless of approach), and some see the formatting method as redundant given the pervasiveness of the expression. On the other hand, the formatting method also offers a few potential advantages. For example, the original % expression can’t handle keywords, attribute references, and binary type codes, although dictionary key references in % format strings can often achieve similar goals. To see how the two techniques overlap, compare the following % expressions to the equivalent format method calls shown earlier: >>> '%s, %s and %s' % (3.14, 42, [1, 2]) # Arbitrary types '3.14, 42 and [1, 2]' >>> 'My %(kind)s runs %(platform)s' % {'kind': 'laptop', 'platform': sys.platform} 'My laptop runs win32' >>> 'My %(kind)s runs %(platform)s' % dict(kind='laptop', platform=sys.platform) 'My laptop runs win32' >>> somelist = list('SPAM') String Formatting Method Calls | 227
- 280. >>> parts = somelist[0], somelist[-1], somelist[1:3] >>> 'first=%s, last=%s, middle=%s' % parts "first=S, last=M, middle=['P', 'A']" When more complex formatting is applied the two techniques approach parity in terms of complexity, although if you compare the following with the format method call equivalents listed earlier you’ll again find that the % expressions tend to be a bit simpler and more concise; in Python 3.3: # Adding specific formatting >>> '%-10s = %10s' % ('spam', 123.4567) 'spam = 123.4567' >>> '%10s = %-10s' % ('spam', 123.4567) ' spam = 123.4567 ' >>> '%(plat)10s = %(kind)-10s' % dict(plat=sys.platform, kind='laptop') ' win32 = laptop ' # Floating-point numbers >>> '%e, %.3e, %g' % (3.14159, 3.14159, 3.14159) '3.141590e+00, 3.142e+00, 3.14159' >>> '%f, %.2f, %06.2f' % (3.14159, 3.14159, 3.14159) '3.141590, 3.14, 003.14' # Hex and octal, but not binary (see ahead) >>> '%x, %o' % (255, 255) 'ff, 377' The format method has a handful of advanced features that the % expression does not, but even more involved formatting still seems to be essentially a draw in terms of com- plexity. For instance, the following shows the same result generated with both techni- ques, with field sizes and justifications and various argument reference methods: # Hardcoded references in both >>> import sys >>> 'My {1[kind]:<8} runs {0.platform:>8}'.format(sys, {'kind': 'laptop'}) 'My laptop runs win32' >>> 'My %(kind)-8s runs %(plat)8s' % dict(kind='laptop', plat=sys.platform) 'My laptop runs win32' In practice, programs are less likely to hardcode references like this than to execute code that builds up a set of substitution data ahead of time (for instance, to collect input form or database data to substitute into an HTML template all at once). When we account for common practice in examples like this, the comparison between the format method and the % expression is even more direct: 228 | Chapter 7: String Fundamentals
- 281. # Building data ahead of time in both >>> data = dict(platform=sys.platform, kind='laptop') >>> 'My {kind:<8} runs {platform:>8}'.format(**data) 'My laptop runs win32' >>> 'My %(kind)-8s runs %(platform)8s' % data 'My laptop runs win32' As we’ll see in Chapter 18, the **data in the method call here is special syntax that unpacks a dictionary of keys and values into individual “name=value” keyword argu- ments so they can be referenced by name in the format string—another unavoidable far conceptual forward reference to function call tools, which may be another downside of the format method in general, especially for newcomers. As usual, though, the Python community will have to decide whether % expressions, format method calls, or a toolset with both techniques proves better over time. Experi- ment with these techniques on your own to get a feel for what they offer, and be sure to see the library reference manuals for Python 2.6, 3.0, and later for more details. String format method enhancements in Python 3.1 and 2.7: Python 3.1 and 2.7 added a thousand-separator syntax for numbers, which inserts commas between three-digit groups. To make this work, add a comma before the type code, and between the width and precision if present, as follows: >>> '{0:d}'.format(999999999999) '999999999999' >>> '{0:,d}'.format(999999999999) '999,999,999,999' These Pythons also assign relative numbers to substitution targets au- tomatically if they are not included explicitly, though using this exten- sion doesn’t apply in all use cases, and may negate one of the main benefits of the formatting method—its more explicit code: >>> '{:,d}'.format(999999999999) '999,999,999,999' >>> '{:,d} {:,d}'.format(9999999, 8888888) '9,999,999 8,888,888' >>> '{:,.2f}'.format(296999.2567) '296,999.26' Seethe3.1releasenotesformoredetails.Seealsotheformats.pycomma- insertion and money-formatting function examples in Chapter 25 for a simple manual solution that can be imported and used prior to Python 3.1 and 2.7. As typical in programming, it’s straightforward to imple- ment new functionality in a callable, reusable, and customizable func- tion of your own, rather than relying on a fixed set of built-in tools: >>> from formats import commas, money >>> '%s' % commas(999999999999) '999,999,999,999' >>> '%s %s' % (commas(9999999), commas(8888888)) String Formatting Method Calls | 229
- 282. '9,999,999 8,888,888' >>> '%s' % money(296999.2567) '$296,999.26' Andasusual,asimplefunctionlikethiscanbeappliedinmoreadvanced contexts too, such as the iteration tools we met in Chapter 4 and will study fully in later chapters: >>> [commas(x) for x in (9999999, 8888888)] ['9,999,999', '8,888,888'] >>> '%s %s' % tuple(commas(x) for x in (9999999, 8888888)) '9,999,999 8,888,888' >>> ''.join(commas(x) for x in (9999999, 8888888)) '9,999,9998,888,888' For better or worse, Python developers often seem to prefer adding spe- cial-case built-in tools over general development techniques—a tradeoff explored in the next section. Why the Format Method? Now that I’ve gone to such lengths to compare and contrast the two formatting tech- niques, I wish to also explain why you still might want to consider using the format method variant at times. In short, although the formatting method can sometimes re- quire more code, it also: • Has a handful of extra features not found in the % expression itself (though % can use alternatives) • Has more flexible value reference syntax (though it may be overkill, and % often has equivalents) • Can make substitution value references more explicit (though this is now optional) • Trades an operator for a more mnemonic method name (though this is also more verbose) • Does not allow different syntax for single and multiple values (though practice suggests this is trivial) • As a function can be used in places an expression cannot (though a one-line func- tion renders this moot) Although both techniques are available today and the formatting expression is still widely used, the format method might eventually grow in popularity and may receive more attention from Python developers in the future. Further, with both the expression and method in the language, either may appear in code you will encounter so it be- hooves you to understand both. But because the choice is currently still yours to make in new code, let’s briefly expand on the tradeoffs before closing the book on this topic. Extra features: Special-case “batteries” versus general techniques The method call supports a few extras that the expression does not, such as binary type codes and (as of Python 2.7 and 3.1) thousands groupings. As we’ve seen, though, the 230 | Chapter 7: String Fundamentals
- 283. formatting expression can usually achieve the same effects in other ways. Here’s the case for binary formatting: >>> '{0:b}'.format((2 ** 16) − 1) # Expression (only) binary format code '1111111111111111' >>> '%b' % ((2 ** 16) − 1) ValueError: unsupported format character 'b'... >>> bin((2 ** 16) − 1) # But other more general options work too '0b1111111111111111' >>> '%s' % bin((2 ** 16) - 1) # Usable with both method and % expression '0b1111111111111111' >>> '{}'.format(bin((2 ** 16) - 1)) # With 2.7/3.1+ relative numbering '0b1111111111111111' >>> '%s' % bin((2 ** 16) - 1)[2:] # Slice off 0b to get exact equivalent '1111111111111111' The preceding note showed that general functions could similarly stand in for the for- mat method’s thousands groupings option, and more fully support customization. In thiscase,asimple8-linereusablefunctionbuysusthesameutilitywithoutextraspecial- case syntax: >>> '{:,d}'.format(999999999999) # New str.format method feature in 3.1/2.7 '999,999,999,999' >>> '%s' % commas(999999999999) # But % is same with simple 8-line function '999,999,999,999' See the prior note for more comma comparisons. This is essentially the same as the preceding bin case for binary formatting, but the commas function here is user-defined, not built in. As such, this technique is far more general purpose than precoded tools or special syntax added for a single purpose. This case also seems indicative, perhaps, of a trend in Python (and scripting language in general) toward relying more on special-case “batteries included” tools than on gen- eral development techniques—a mindset that makes code dependent on those batter- ies, and seems difficult to justify unless one views software development as an end-user enterprise. To some, programmers might be better served learning how to code an algorithm to insert commas than be provided a tool that does. We’ll leave that philosophical debate aside here, but in practical terms the net effect of the trend in this case is extra syntax for you to have to both learn and remember. Given their alternatives, it’s not clear that these extra features of the methods by themselves are compelling enough to be decisive. Flexible reference syntax: Extra complexity and functional overlap The method call also supports key and attribute references directly, which some may see as more flexible. But as we saw in earlier examples comparing dictionary-based formatting in the % expression to key and attribute references in the format method, the String Formatting Method Calls | 231
- 284. two are usually too similar to warrant a preference on these grounds. For instance, both can reference the same value multiple times: >>> '{name} {job} {name}'.format(name='Bob', job='dev') 'Bob dev Bob' >>> '%(name)s %(job)s %(name)s' % dict(name='Bob', job='dev') 'Bob dev Bob' Especially in common practice, though, the expression seems just as simple, or simpler: >>> D = dict(name='Bob', job='dev') >>> '{0[name]} {0[job]} {0[name]}'.format(D) # Method, key references 'Bob dev Bob' >>> '{name} {job} {name}'.format(**D) # Method, dict-to-args 'Bob dev Bob' >>> '%(name)s %(job)s %(name)s' % D # Expression, key references 'Bob dev Bob' To be fair, the method has even more specialized substitution syntax, and other com- parisons might favor either scheme in small ways. But given the overlap and extra complexity, one could argue that the format method’s utility seems either a wash, or features in search of use cases. At the least, the added conceptual burden on Python programmers who may now need to know both tools doesn’t seem clearly justified. Explicit value references: Now optional and unlikely to be used One use case where the format method is at least debatably clearer is when there are many values to be substituted into the format string. The lister.py classes example we’ll meet in Chapter 31, for example, substitutes six items into a single string, and in this case the method’s {i} position labels seem marginally easier to read than the expres- sion’s %s: 'n%s<Class %s, address %s:n%s%s%s>n' % (...) # Expression 'n{0}<Class {1}, address {2}:n{3}{4}{5}>n'.format(...) # Method On the other hand, using dictionary keys in % expressions can mitigate much of this difference. This is also something of a worst-case scenario for formatting complexity, andnotverycommoninpractice;moretypicalusecasesseemmoreofatossup.Further, as of Python 3.1 and 2.7, numbering substitution targets becomes optional when rel- ative to position, potentially subverting this purported benefit altogether: >>> 'The {0} side {1} {2}'.format('bright', 'of', 'life') # Python 3.X, 2.6+ 'The bright side of life' >>> 'The {} side {} {}'.format('bright', 'of', 'life') # Python 3.1+, 2.7+ 'The bright side of life' >>> 'The %s side %s %s' % ('bright', 'of', 'life') # All Pythons 'The bright side of life' Given its conciseness, the second of these is likely to be preferred to the first, but seems to negate part of the method’s advantage. Compare the effect on floating-point for- 232 | Chapter 7: String Fundamentals
- 285. matting, for example—the formatting expression is still more concise, and still seems less cluttered: >>> '{0:f}, {1:.2f}, {2:05.2f}'.format(3.14159, 3.14159, 3.14159) '3.141590, 3.14, 03.14' >>> '{:f}, {:.2f}, {:06.2f}'.format(3.14159, 3.14159, 3.14159) '3.141590, 3.14, 003.14' >>> '%f, %.2f, %06.2f' % (3.14159, 3.14159, 3.14159) '3.141590, 3.14, 003.14' Named method and context-neutral arguments: Aesthetics versus practice The formatting method also claims an advantage in replacing the % operator with a more mnemonic format method name, and not distinguishing between single and mul- tiple substitution values. The former may make the method appear simpler to beginners at first glance (“format” may be easier to parse than multiple “%” characters), though this probably varies per reader and seems minor. Some may see the latter difference as more significant—with the format expression, a single value can be given by itself, but multiple values must be enclosed in a tuple: >>> '%.2f' % 1.2345 # Single value '1.23' >>> '%.2f %s' % (1.2345, 99) # Multiple values tuple '1.23 99' Technically, the formatting expression accepts either a single substitution value, or a tuple of one or more items. As a consequence, because a single item can be given either by itself or within a tuple, a tuple to be formatted must be provided as a nested tuple —a perhaps rare but plausible case: >>> '%s' % 1.23 # Single value, by itself '1.23' >>> '%s' % (1.23,) # Single value, in a tuple '1.23' >>> '%s' % ((1.23,),) # Single value that is a tuple '(1.23,)' The formatting method, on the other hand, tightens this up by accepting only general function arguments in both cases, instead of requiring a tuple both for multiple values or a single value that is a tuple: >>> '{0:.2f}'.format(1.2345) # Single value '1.23' >>> '{0:.2f} {1}'.format(1.2345, 99) # Multiple values '1.23 99' >>> '{0}'.format(1.23) # Single value, by itself '1.23' >>> '{0}'.format((1.23,)) # Single value that is a tuple '(1.23,)' String Formatting Method Calls | 233
- 286. Consequently, the method might be less confusing to beginners and cause fewer pro- gramming mistakes. This seems a fairly minor issue, though—if you always enclose values in a tuple and ignore the nontupled option, the expression is essentially the same as the method call here. Moreover, the method incurs a price in inflated code size to achieve its constrained usage mode. Given the expression’s wide use over Python’s history, this issue may be more theoretical than practical, and may not justify porting existing code to a new tool that is so similar to that it seeks to subsume. Functions versus expressions: A minor convenience The final rationale for the format method—it’s a function that can appear where an expression cannot—requires more information about functions than we yet have at this point in the book, so we won’t dwell on it here. Suffice it to say that both the str.format method and the format built-in function can be passed to other functions, stored in other objects, and so on. An expression like % cannot directly, but this may be narrow-sighted—it’s trivial to wrap any expression in a one-line def or partial-line lambda once to turn it into a function with the same properties (though finding a reason to do so may be more challenging): def myformat(fmt, args): return fmt % args # See Part IV myformat('%s %s', (88, 99)) # Call your function object str.format('{} {}', 88, 99) # Versus calling the built-in otherfunction(myformat) # Your function is an object too In the end, this may not be an either/or choice. While the expression still seems more pervasive in Python code, both formatting expressions and methods are available for use in Python today, and most programmers will benefit from being familiar with both techniques for years to come. That may double the work of newcomers to the language in this department, but in this bazaar of ideas we call the open source software world, there always seems to be room for more.2 Plus one more: Technically speaking, there are 3 (not 2) formatting tools built into Python, if we include the obscure string module’s Template tool mentioned earlier. Now that we’ve seen the other two, I can show you how it compares. The expression and method can be used as tem- plating tools too, referring to substitution values by name via dictionary keys or keyword arguments: >>> '%(num)i = %(title)s' % dict(num=7, title='Strings') '7 = Strings' 2. See also the Chapter 31 note about a str.format bug (or regression) in Pythons 3.2 and 3.3 concerning generic empty substitution targets for object attributes that define no __format__ handler. This impacted a working example from this book’s prior edition. While it may be a temporary regression, it does at the least underscore that this method is still a bit of a moving target—yet another reason to question the feature redundancy it implies. 234 | Chapter 7: String Fundamentals
- 287. >>> '{num:d} = {title:s}'.format(num=7, title='Strings') '7 = Strings' >>> '{num} = {title}'.format(**dict(num=7, title='Strings')) '7 = Strings' The module’s templating system allows values to be referenced by name too, prefixed by a $, as either dictionary keys or keywords, but does not support all the utilities of the other two methods—a limitation that yields simplicity, the prime motivation for this tool: >>> import string >>> t = string.Template('$num = $title') >>> t.substitute({'num': 7, 'title': 'Strings'}) '7 = Strings' >>> t.substitute(num=7, title='Strings') '7 = Strings' >>> t.substitute(dict(num=7, title='Strings')) '7 = Strings' See Python’s manuals for more details. It’s possible that you may see this alternative (as well as additional tools in the third-party domain) in Python code too; thankfully this technique is simple, and is used rarely enough to warrant its limited coverage here. The best bet for most new- comers today is to learn and use %, str.format, or both. General Type Categories Now that we’ve explored the first of Python’s collection objects, the string, let’s close this chapter by defining a few general type concepts that will apply to most of the types we look at from here on. With regard to built-in types, it turns out that operations work the same for all the types in the same category, so we’ll only need to define most of these ideas once. We’ve only examined numbers and strings so far, but because they are representative of two of the three major type categories in Python, you already know more about several other types than you might think. Types Share Operation Sets by Categories As you’ve learned, strings are immutable sequences: they cannot be changed in place (the immutable part), and they are positionally ordered collections that are accessed by offset (the sequence part). It so happens that all the sequences we’ll study in this part of the book respond to the same sequence operations shown in this chapter at work on strings—concatenation, indexing, iteration, and so on. More formally, there are three major type (and operation) categories in Python that have this generic nature: Numbers (integer, floating-point, decimal, fraction, others) Support addition, multiplication, etc. Sequences (strings, lists, tuples) Support indexing, slicing, concatenation, etc. General Type Categories | 235
- 288. Mappings (dictionaries) Support indexing by key, etc. I’m including the Python 3.X byte strings and 2.X Unicode strings I mentioned at the start of this chapter under the general “strings” label here (see Chapter 37). Sets are something of a category unto themselves (they don’t map keys to values and are not positionallyorderedsequences),andwehaven’tyetexploredmappingsonourin-depth tour (we will in the next chapter). However, many of the other types we will encounter will be similar to numbers and strings. For example, for any sequence objects X and Y: • X + Y makes a new sequence object with the contents of both operands. • X * N makes a new sequence object with N copies of the sequence operand X. In other words, these operations work the same way on any kind of sequence, including strings, lists, tuples, and some user-defined object types. The only difference is that the new result object you get back is of the same type as the operands X and Y—if you concatenate lists, you get back a new list, not a string. Indexing, slicing, and other sequence operations work the same on all sequences, too; the type of the objects being processed tells Python which flavor of the task to perform. Mutable Types Can Be Changed in Place The immutable classification is an important constraint to be aware of, yet it tends to trip up new users. If an object type is immutable, you cannot change its value in place; Python raises an error if you try. Instead, you must run code to make a new object containing the new value. The major core types in Python break down as follows: Immutables (numbers, strings, tuples, frozensets) None of the object types in the immutable category support in-place changes, though we can always run expressions to make new objects and assign their results to variables as needed. Mutables (lists, dictionaries, sets, bytearray) Conversely, the mutable types can always be changed in place with operations that do not create new objects. Although such objects can be copied, in-place changes support direct modification. Generally, immutable types give some degree of integrity by guaranteeing that an object won’t be changed by another part of a program. For a refresher on why this matters, see the discussion of shared object references in Chapter 6. To see how lists, diction- aries, and tuples participate in type categories, we need to move ahead to the next chapter. 236 | Chapter 7: String Fundamentals
- 289. Chapter Summary In this chapter, we took an in-depth tour of the string object type. We learned about coding string literals, and we explored string operations, including sequence expres- sions, string method calls, and string formatting with both expressions and method calls. Along the way, we studied a variety of concepts in depth, such as slicing, method call syntax, and triple-quoted block strings. We also defined some core ideas common to a variety of types: sequences, for example, share an entire set of operations. In the next chapter, we’ll continue our types tour with a look at the most general object collections in Python—lists and dictionaries. As you’ll find, much of what you’ve learned here will apply to those types as well. And as mentioned earlier, in the final part of this book we’ll return to Python’s string model to flesh out the details of Unicode text and binary data, which are of interest to some, but not all, Python programmers. Before moving on, though, here’s another chapter quiz to review the material covered here. Test Your Knowledge: Quiz 1. Can the string find method be used to search a list? 2. Can a string slice expression be used on a list? 3. How would you convert a character to its ASCII integer code? How would you convert the other way, from an integer to a character? 4. How might you go about changing a string in Python? 5. Given a string S with the value "s,pa,m", name two ways to extract the two char- acters in the middle. 6. How many characters are there in the string "anbx1f000d"? 7. Why might you use the string module instead of string method calls? Test Your Knowledge: Answers 1. No, because methods are always type-specific; that is, they only work on a single data type. Expressions like X+Y and built-in functions like len(X) are generic, though, and may work on a variety of types. In this case, for instance, the in mem- bership expression has a similar effect as the string find, but it can be used to search both strings and lists. In Python 3.X, there is some attempt to group methods by categories (for example, the mutable sequence types list and bytearray have sim- ilar method sets), but methods are still more type-specific than other operation sets. 2. Yes. Unlike methods, expressions are generic and apply to many types. In this case, the slice expression is really a sequence operation—it works on any type of se- Test Your Knowledge: Answers | 237
- 290. quence object, including strings, lists, and tuples. The only difference is that when you slice a list, you get back a new list. 3. The built-in ord(S) function converts from a one-character string to an integer character code; chr(I) converts from the integer code back to a string. Keep in mind, though, that these integers are only ASCII codes for text whose characters are drawn only from ASCII character set. In the Unicode model, text strings are really sequences of Unicode code point identifying integers, which may fall outside the 7-bit range of numbers reserved by ASCII (more on Unicode in Chapter 4 and Chapter 37). 4. Strings cannot be changed; they are immutable. However, you can achieve a similar effect by creating a new string—by concatenating, slicing, running formatting ex- pressions, or using a method call like replace—and then assigning the result back to the original variable name. 5. You can slice the string using S[2:4], or split on the comma and index the string using S.split(',')[1]. Try these interactively to see for yourself. 6. Six. The string "anbx1f000d" contains the characters a, newline (n), b, binary 31 (a hex escape x1f), binary 0 (an octal escape 000), and d. Pass the string to the built-in len function to verify this, and print each of its character’s ord results to seetheactualcodepoint(identifyingnumber)values.SeeTable7-2 formoredetails on escapes. 7. You should never use the string module instead of string object method calls today —it’s deprecated, and its calls are removed completely in Python 3.X. The only valid reason for using the string module at all today is for its other tools, such as predefined constants. You might also see it appear in what is now very old and dusty Python code (and books of the misty past—like the 1990s). 238 | Chapter 7: String Fundamentals
- 291. CHAPTER 8 Lists and Dictionaries Now that we’ve learned about numbers and strings, this chapter moves on to give the full story on Python’s list and dictionary object types—collections of other objects, and the main workhorses in almost all Python scripts. As you’ll see, both types are remark- ably flexible: they can be changed in place, can grow and shrink on demand, and may contain and be nested in any other kind of object. By leveraging these types, you can build up and process arbitrarily rich information structures in your scripts. Lists The next stop on our built-in object tour is the Python list. Lists are Python’s most flexible ordered collection object type. Unlike strings, lists can contain any sort of ob- ject: numbers, strings, and even other lists. Also, unlike strings, lists may be changed in place by assignment to offsets and slices, list method calls, deletion statements, and more—they are mutable objects. Python lists do the work of many of the collection data structures you might have to implement manually in lower-level languages such as C. Here is a quick look at their main properties. Python lists are: Ordered collections of arbitrary objects From a functional view, lists are just places to collect other objects so you can treat them as groups. Lists also maintain a left-to-right positional ordering among the items they contain (i.e., they are sequences). Accessed by offset Just as with strings, you can fetch a component object out of a list by indexing the list on the object’s offset. Because items in lists are ordered by their positions, you can also do tasks such as slicing and concatenation. Variable-length, heterogeneous, and arbitrarily nestable Unlike strings, lists can grow and shrink in place (their lengths can vary), and they can contain any sort of object, not just one-character strings (they’re heterogene- 239
- 292. ous). Because lists can contain other complex objects, they also support arbitrary nesting; you can create lists of lists of lists, and so on. Of the category “mutable sequence” In terms of our type category qualifiers, lists are mutable (i.e., can be changed in place) and can respond to all the sequence operations used with strings, such as indexing, slicing, and concatenation. In fact, sequence operations work the same on lists as they do on strings; the only difference is that sequence operations such as concatenation and slicing return new lists instead of new strings when applied to lists. Because lists are mutable, however, they also support other operations that strings don’t, such as deletion and index assignment operations, which change the lists in place. Arrays of object references Technically, Python lists contain zero or more references to other objects. Lists might remind you of arrays of pointers (addresses) if you have a background in some other languages. Fetching an item from a Python list is about as fast as in- dexing a C array; in fact, lists really are arrays inside the standard Python inter- preter, not linked structures. As we learned in Chapter 6, though, Python always follows a reference to an object whenever the reference is used, so your program deals only with objects. Whenever you assign an object to a data structure com- ponent or variable name, Python always stores a reference to that same object, not a copy of it (unless you request a copy explicitly). As a preview and reference, Table 8-1 summarizes common and representative list object operations. It is fairly complete for Python 3.3, but for the full story, consult the Python standard library manual, or run a help(list) or dir(list) call interactively for a complete list of list methods—you can pass in a real list, or the word list, which is the name of the list data type. The set of methods here is especially prone to change— in fact, two are new as of Python 3.3. Table 8-1. Common list literals and operations Operation Interpretation L = [] An empty list L = [123, 'abc', 1.23, {}] Four items: indexes 0..3 L = ['Bob', 40.0, ['dev', 'mgr']] Nested sublists L = list('spam') L = list(range(-4, 4)) List of an iterable’s items, list of successive integers L[i] L[i][j] L[i:j] len(L) Index, index of index, slice, length L1 + L2 Concatenate, repeat 240 | Chapter 8: Lists and Dictionaries
- 293. Operation Interpretation L * 3 for x in L: print(x) 3 in L Iteration, membership L.append(4) L.extend([5,6,7]) L.insert(i, X) Methods: growing L.index(X) L.count(X) Methods: searching L.sort() L.reverse() L.copy() L.clear() Methods: sorting, reversing, copying (3.3+), clearing (3.3+) L.pop(i) L.remove(X) del L[i] del L[i:j] L[i:j] = [] Methods, statements: shrinking L[i] = 3 L[i:j] = [4,5,6] Index assignment, slice assignment L = [x**2 for x in range(5)] list(map(ord, 'spam')) List comprehensions and maps (Chapter 4, Chapter 14, Chapter 20) When written down as a literal expression, a list is coded as a series of objects (really, expressions that return objects) in square brackets, separated by commas. For instance, the second row in Table 8-1 assigns the variable L to a four-item list. A nested list is coded as a nested square-bracketed series (row 3), and the empty list is just a square- bracket pair with nothing inside (row 1).1 Many of the operations in Table 8-1 should look familiar, as they are the same sequence operations we put to work on strings earlier—indexing, concatenation, iteration, and so on. Lists also respond to list-specific method calls (which provide utilities such as sorting, reversing, adding items to the end, etc.), as well as in-place change operations 1. In practice, you won’t see many lists written out like this in list-processing programs. It’s more common to see code that processes lists constructed dynamically (at runtime), from user inputs, file contents, and so on. In fact, although it’s important to master literal syntax, many data structures in Python are built by running program code at runtime. Lists | 241
- 294. (deleting items, assignment to indexes and slices, and so forth). Lists have these tools for change operations because they are a mutable object type. Lists in Action Perhaps the best way to understand lists is to see them at work. Let’s once again turn to some simple interpreter interactions to illustrate the operations in Table 8-1. Basic List Operations Because they are sequences, lists support many of the same operations as strings. For example, lists respond to the + and * operators much like strings—they mean concat- enation and repetition here too, except that the result is a new list, not a string: % python >>> len([1, 2, 3]) # Length 3 >>> [1, 2, 3] + [4, 5, 6] # Concatenation [1, 2, 3, 4, 5, 6] >>> ['Ni!'] * 4 # Repetition ['Ni!', 'Ni!', 'Ni!', 'Ni!'] Although the + operator works the same for lists and strings, it’s important to know that it expects the same sort of sequence on both sides—otherwise, you get a type error when the code runs. For instance, you cannot concatenate a list and a string unless you first convert the list to a string (using tools such as str or % formatting) or convert the string to a list (the list built-in function does the trick): >>> str([1, 2]) + "34" # Same as "[1, 2]" + "34" '[1, 2]34' >>> [1, 2] + list("34") # Same as [1, 2] + ["3", "4"] [1, 2, '3', '4'] List Iteration and Comprehensions More generally, lists respond to all the sequence operations we used on strings in the prior chapter, including iteration tools: >>> 3 in [1, 2, 3] # Membership True >>> for x in [1, 2, 3]: ... print(x, end=' ') # Iteration (2.X uses: print x,) ... 1 2 3 We will talk more formally about for iteration and the range built-ins of Table 8-1 in Chapter 13, because they are related to statement syntax. In short, for loops step through items in any sequence from left to right, executing one or more statements for each item; range produces successive integers. 242 | Chapter 8: Lists and Dictionaries
- 295. The last items in Table 8-1, list comprehensions and map calls, are covered in more detail in Chapter 14 and expanded on in Chapter 20. Their basic operation is straightforward, though—as introduced in Chapter 4, list comprehensions are a way to build a new list by applying an expression to each item in a sequence (really, in any iterable), and are close relatives to for loops: >>> res = [c * 4 for c in 'SPAM'] # List comprehensions >>> res ['SSSS', 'PPPP', 'AAAA', 'MMMM'] This expression is functionally equivalent to a for loop that builds up a list of results manually, but as we’ll learn in later chapters, list comprehensions are simpler to code and likely faster to run today: >>> res = [] >>> for c in 'SPAM': # List comprehension equivalent ... res.append(c * 4) ... >>> res ['SSSS', 'PPPP', 'AAAA', 'MMMM'] As also introduced briefly in Chapter 4, the map built-in function does similar work, but applies a function to items in a sequence and collects all the results in a new list: >>> list(map(abs, [−1, −2, 0, 1, 2])) # Map a function across a sequence [1, 2, 0, 1, 2] Because we’re not quite ready for the full iteration story, we’ll postpone further details for now, but watch for a similar comprehension expression for dictionaries later in this chapter. Indexing, Slicing, and Matrixes Because lists are sequences, indexing and slicing work the same way for lists as they do for strings. However, the result of indexing a list is whatever type of object lives at the offset you specify, while slicing a list always returns a new list: >>> L = ['spam', 'Spam', 'SPAM!'] >>> L[2] # Offsets start at zero 'SPAM!' >>> L[−2] # Negative: count from the right 'Spam' >>> L[1:] # Slicing fetches sections ['Spam', 'SPAM!'] One note here: because you can nest lists and other object types within lists, you will sometimes need to string together index operations to go deeper into a data structure. For example, one of the simplest ways to represent matrixes (multidimensional arrays) in Python is as lists with nested sublists. Here’s a basic 3 × 3 two-dimensional list-based array: >>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Lists in Action | 243
- 296. With one index, you get an entire row (really, a nested sublist), and with two, you get an item within the row: >>> matrix[1] [4, 5, 6] >>> matrix[1][1] 5 >>> matrix[2][0] 7 >>> matrix = [[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9]] >>> matrix[1][1] 5 Notice in the preceding interaction that lists can naturally span multiple lines if you want them to because they are contained by a pair of brackets; the “...”s here are Python’s continuation line prompt (see Chapter 4 for comparable code without the “...”s, and watch for more on syntax in the next part of the book). For more on matrixes, watch later in this chapter for a dictionary-based matrix repre- sentation, which can be more efficient when matrixes are largely empty. We’ll also continue this thread in Chapter 20 where we’ll write additional matrix code, especially with list comprehensions. For high-powered numeric work, the NumPy extension mentioned in Chapter 4 and Chapter 5 provides other ways to handle matrixes. Changing Lists in Place Because lists are mutable, they support operations that change a list object in place. That is, the operations in this section all modify the list object directly—overwriting its former value—without requiring that you make a new copy, as you had to for strings. Because Python deals only in object references, this distinction between changing an object in place and creating a new object matters; as discussed in Chapter 6, if you change an object in place, you might impact more than one reference to it at the same time. Index and slice assignments When using a list, you can change its contents by assigning to either a particular item (offset) or an entire section (slice): >>> L = ['spam', 'Spam', 'SPAM!'] >>> L[1] = 'eggs' # Index assignment >>> L ['spam', 'eggs', 'SPAM!'] >>> L[0:2] = ['eat', 'more'] # Slice assignment: delete+insert >>> L # Replaces items 0,1 ['eat', 'more', 'SPAM!'] 244 | Chapter 8: Lists and Dictionaries
- 297. Both index and slice assignments are in-place changes—they modify the subject list directly, rather than generating a new list object for the result. Index assignment in Python works much as it does in C and most other languages: Python replaces the single object reference at the designated offset with a new one. Slice assignment, the last operation in the preceding example, replaces an entire section of a list in a single step. Because it can be a bit complex, it is perhaps best thought of as a combination of two steps: 1. Deletion. The slice you specify to the left of the = is deleted. 2. Insertion. The new items contained in the iterable object to the right of the = are inserted into the list on the left, at the place where the old slice was deleted.2 This isn’t what really happens, but it can help clarify why the number of items inserted doesn’t have to match the number of items deleted. For instance, given a list L of two or more items, an assignment L[1:2]=[4,5] replaces one item with two—Python first deletes the one-item slice at [1:2] (from offset 1, up to but not including offset 2), then inserts both 4 and 5 where the deleted slice used to be. This also explains why the second slice assignment in the following is really an insert —Python replaces an empty slice at [1:1] with two items; and why the third is really a deletion—Python deletes the slice (the item at offset 1), and then inserts nothing: >>> L = [1, 2, 3] >>> L[1:2] = [4, 5] # Replacement/insertion >>> L [1, 4, 5, 3] >>> L[1:1] = [6, 7] # Insertion (replace nothing) >>> L [1, 6, 7, 4, 5, 3] >>> L[1:2] = [] # Deletion (insert nothing) >>> L [1, 7, 4, 5, 3] In effect, slice assignment replaces an entire section, or “column,” all at once—even if the column or its replacement is empty. Because the length of the sequence being as- signed does not have to match the length of the slice being assigned to, slice assignment can be used to replace (by overwriting), expand (by inserting), or shrink (by deleting) the subject list. It’s a powerful operation, but frankly, one that you may not see very often in practice. There are often more straightforward and mnemonic ways to replace, insert, and delete (concatenation, and the insert, pop, and remove list methods, for example), which Python programmers tend to prefer in practice. 2. This description requires elaboration when the value and the slice being assigned overlap: L[2:5]=L[3:6], for instance, works fine because the value to be inserted is fetched before the deletion happens on the left. Lists in Action | 245
- 298. On the other hand, this operation can be used as a sort of in-place concatenation at the front of the list—per the next section’s method coverage, something the list’s extend does more mnemonically at list end: >>> L = [1] >>> L[:0] = [2, 3, 4] # Insert all at :0, an empty slice at front >>> L [2, 3, 4, 1] >>> L[len(L):] = [5, 6, 7] # Insert all at len(L):, an empty slice at end >>> L [2, 3, 4, 1, 5, 6, 7] >>> L.extend([8, 9, 10]) # Insert all at end, named method >>> L [2, 3, 4, 1, 5, 6, 7, 8, 9, 10] List method calls Like strings, Python list objects also support type-specific method calls, many of which change the subject list in place: >>> L = ['eat', 'more', 'SPAM!'] >>> L.append('please') # Append method call: add item at end >>> L ['eat', 'more', 'SPAM!', 'please'] >>> L.sort() # Sort list items ('S' < 'e') >>> L ['SPAM!', 'eat', 'more', 'please'] Methods were introduced in Chapter 7. In brief, they are functions (really, object at- tributes that reference functions) that are associated with and act upon particular ob- jects. Methods provide type-specific tools; the list methods presented here, for instance, are generally available only for lists. Perhaps the most commonly used list method is append, which simply tacks a single item (object reference) onto the end of the list. Unlike concatenation, append expects you to pass in a single object, not a list. The effect of L.append(X) is similar to L+[X], but while the former changes L in place, the latter makes a new list.3 The sort method orders the list’s items here, but merits a section of its own. More on sorting lists Another commonly seen method, sort, orders a list in place; it uses Python standard comparison tests (here, string comparisons, but applicable to every object type), and 3. Unlike + concatenation, append doesn’t have to generate new objects, so it’s usually faster than + too. You can also mimic append with the clever slice assignments of the prior section: L[len(L):]=[X] is like L.append(X), and L[:0]=[X] is like appending at the front of a list. Both delete an empty slice and insert X, changing L in place quickly, like append. Both are arguably more complex than list methods, though. For instance, L.insert(0, X) can also append an item to the front of a list, and seems noticeably more mnemonic; L.insert(len(L), X) inserts one object at the end too, but unless you like typing, you might as well use L.append(X)! 246 | Chapter 8: Lists and Dictionaries
- 299. by default sorts in ascending order. You can modify sort behavior by passing in keyword arguments—a special “name=value” syntax in function calls that specifies passing by name and is often used for giving configuration options. In sorts, the reverse argument allows sorts to be made in descending instead of as- cending order, and the key argument gives a one-argument function that returns the value to be used in sorting—the string object’s standard lower case converter in the following (though its newer casefold may handle some types of Unicode text better): >>> L = ['abc', 'ABD', 'aBe'] >>> L.sort() # Sort with mixed case >>> L ['ABD', 'aBe', 'abc'] >>> L = ['abc', 'ABD', 'aBe'] >>> L.sort(key=str.lower) # Normalize to lowercase >>> L ['abc', 'ABD', 'aBe'] >>> >>> L = ['abc', 'ABD', 'aBe'] >>> L.sort(key=str.lower, reverse=True) # Change sort order >>> L ['aBe', 'ABD', 'abc'] The sort key argument might also be useful when sorting lists of dictionaries, to pick out a sort key by indexing each dictionary. We’ll study dictionaries later in this chapter, and you’ll learn more about keyword function arguments in Part IV. Comparison and sorts in 3.X: In Python 2.X, relative magnitude com- parisons of differently typed objects (e.g., a string and a list) work—the language defines a fixed ordering among different types, which is de- terministic, if not aesthetically pleasing. That is, the ordering is based on the names of the types involved: all integers are less than all strings, for example, because "int" is less than "str". Comparisons never au- tomatically convert types, except when comparing numeric type ob- jects. In Python 3.X, this has changed: magnitude comparison of mixed types raises an exception instead of falling back on the fixed cross-type or- dering. Because sorting uses comparisons internally, this means that [1, 2, 'spam'].sort() succeeds in Python 2.X but will raise an excep- tion in Python 3.X. Sorting mixed-types fails by proxy. Python 3.X also no longer supports passing in an arbitrary comparison function to sorts, to implement different orderings. The suggested work- around is to use the key=func keyword argument to code value trans- formations during the sort, and use the reverse=True keyword argument to change the sort order to descending. These were the typical uses of comparison functions in the past. Lists in Action | 247
- 300. One warning here: beware that append and sort change the associated list object in place, but don’t return the list as a result (technically, they both return a value called None). If you say something like L=L.append(X), you won’t get the modified value of L (in fact, you’ll lose the reference to the list altogether!). When you use attributes such as append and sort, objects are changed as a side effect, so there’s no reason to reassign. Partly because of such constraints, sorting is also available in recent Pythons as a built- in function, which sorts any collection (not just lists) and returns a new list for the result (instead of in-place changes): >>> L = ['abc', 'ABD', 'aBe'] >>> sorted(L, key=str.lower, reverse=True) # Sorting built-in ['aBe', 'ABD', 'abc'] >>> L = ['abc', 'ABD', 'aBe'] >>> sorted([x.lower() for x in L], reverse=True) # Pretransform items: differs! ['abe', 'abd', 'abc'] Notice the last example here—we can convert to lowercase prior to the sort with a list comprehension, but the result does not contain the original list’s values as it does with the key argument. The latter is applied temporarily during the sort, instead of changing the values to be sorted altogether. As we move along, we’ll see contexts in which the sorted built-in can sometimes be more useful than the sort method. Other common list methods Like strings, lists have other methods that perform other specialized operations. For instance, reverse reverses the list in-place, and the extend and pop methods insert mul- tiple items at and delete an item from the end of the list, respectively. There is also a reversed built-in function that works much like sorted and returns a new result object, but it must be wrapped in a list call in both 2.X and 3.X here because its result is an iterator that produces results on demand (more on iterators later): >>> L = [1, 2] >>> L.extend([3, 4, 5]) # Add many items at end (like in-place +) >>> L [1, 2, 3, 4, 5] >>> L.pop() # Delete and return last item (by default: −1) 5 >>> L [1, 2, 3, 4] >>> L.reverse() # In-place reversal method >>> L [4, 3, 2, 1] >>> list(reversed(L)) # Reversal built-in with a result (iterator) [1, 2, 3, 4] Technically, the extend method always iterates through and adds each item in an itera- ble object, whereas append simply adds a single item as is without iterating through it —a distinction that will be more meaningful by Chapter 14. For now, it’s enough to know that extend adds many items, and append adds one. In some types of programs, 248 | Chapter 8: Lists and Dictionaries
- 301. the list pop method is often used in conjunction with append to implement a quick last- in-first-out (LIFO) stack structure. The end of the list serves as the top of the stack: >>> L = [] >>> L.append(1) # Push onto stack >>> L.append(2) >>> L [1, 2] >>> L.pop() # Pop off stack 2 >>> L [1] The pop method also accepts an optional offset of the item to be deleted and returned (the default is the last item at offset −1). Other list methods remove an item by value (remove), insert an item at an offset (insert), count the number of occurrences (count), and search for an item’s offset (index—a search for the index of an item, not to be confused with indexing!): >>> L = ['spam', 'eggs', 'ham'] >>> L.index('eggs') # Index of an object (search/find) 1 >>> L.insert(1, 'toast') # Insert at position >>> L ['spam', 'toast', 'eggs', 'ham'] >>> L.remove('eggs') # Delete by value >>> L ['spam', 'toast', 'ham'] >>> L.pop(1) # Delete by position 'toast' >>> L ['spam', 'ham'] >>> L.count('spam') # Number of occurrences 1 Note that unlike other list methods, count and index do not change the list itself, but return information about its content. See other documentation sources or experiment with these calls interactively on your own to learn more about list methods. Other common list operations Because lists are mutable, you can use the del statement to delete an item or section in place: >>> L = ['spam', 'eggs', 'ham', 'toast'] >>> del L[0] # Delete one item >>> L ['eggs', 'ham', 'toast'] >>> del L[1:] # Delete an entire section >>> L # Same as L[1:] = [] ['eggs'] As we saw earlier, because slice assignment is a deletion plus an insertion, you can also delete a section of a list by assigning an empty list to a slice (L[i:j]=[]); Python deletes Lists in Action | 249
- 302. the slice named on the left, and then inserts nothing. Assigning an empty list to an index, on the other hand, just stores a reference to the empty list object in the specified slot, rather than deleting an item: >>> L = ['Already', 'got', 'one'] >>> L[1:] = [] >>> L ['Already'] >>> L[0] = [] >>> L [[]] Although all the operations just discussed are typical, there may be additional list methods and operations not illustrated here. The method set, for example, may change over time, and in fact has in Python 3.3—its new L.copy() method makes a top-level copy of the list, much like L[:] and list(L), but is symmetric with copy in sets and dictionaries. For a comprehensive and up-to-date list of type tools, you should always consult Python’s manuals, Python’s dir and help functions (which we first met in Chapter 4), or one of the reference texts mentioned in the preface. And because it’s such a common hurdle, I’d also like to remind you again that all the in-place change operations discussed here work only for mutable objects: they won’t work on strings (or tuples, discussed in Chapter 9), no matter how hard you try. Mu- tability is an inherent property of each object type. Dictionaries Along with lists, dictionaries are one of the most flexible built-in data types in Python. If you think of lists as ordered collections of objects, you can think of dictionaries as unordered collections; the chief distinction is that in dictionaries, items are stored and fetched by key, instead of by positional offset. While lists can serve roles similar to arrays in other languages, dictionaries take the place of records, search tables, and any other sort of aggregation where item names are more meaningful than item positions. For example, dictionaries can replace many of the searching algorithms and data struc- tures you might have to implement manually in lower-level languages—as a highly optimized built-in type, indexing a dictionary is a very fast search operation. Diction- aries also sometimes do the work of records, structs, and symbol tables used in other languages; can be used to represent sparse (mostly empty) data structures; and much more. Here’s a rundown of their main properties. Python dictionaries are: Accessed by key, not offset position Dictionaries are sometimes called associative arrays or hashes (especially by users of other scripting languages). They associate a set of values with keys, so you can fetch an item out of a dictionary using the key under which you originally stored it. You use the same indexing operation to get components in a dictionary as you do in a list, but the index takes the form of a key, not a relative offset. 250 | Chapter 8: Lists and Dictionaries
- 303. Unordered collections of arbitrary objects Unlike in a list, items stored in a dictionary aren’t kept in any particular order; in fact, Python pseudo-randomizes their left-to-right order to provide quick lookup. Keys provide the symbolic (not physical) locations of items in a dictionary. Variable-length, heterogeneous, and arbitrarily nestable Like lists, dictionaries can grow and shrink in place (without new copies being made), they can contain objects of any type, and they support nesting to any depth (they can contain lists, other dictionaries, and so on). Each key can have just one associated value, but that value can be a collection of multiple objects if needed, and a given value can be stored under any number of keys. Of the category “mutable mapping” You can change dictionaries in place by assigning to indexes (they are mutable), but they don’t support the sequence operations that work on strings and lists. Because dictionaries are unordered collections, operations that depend on a fixed positional order (e.g., concatenation, slicing) don’t make sense. Instead, diction- aries are the only built-in, core type representatives of the mapping category— objects that map keys to values. Other mappings in Python are created by imported modules. Tables of object references (hash tables) If lists are arrays of object references that support access by position, dictionaries are unordered tables of object references that support access by key. Internally, dictionaries are implemented as hash tables (data structures that support very fast retrieval), which start small and grow on demand. Moreover, Python employs op- timized hashing algorithms to find keys, so retrieval is quick. Like lists, dictionaries store object references (not copies, unless you ask for them explicitly). For reference and preview again, Table 8-2 summarizes some of the most common and representative dictionary operations, and is relatively complete as of Python 3.3. As usual, though, see the library manual or run a dir(dict) or help(dict) call for a com- plete list—dict is the name of the type. When coded as a literal expression, a dictionary is written as a series of key:value pairs, separated by commas, enclosed in curly braces.4 An empty dictionary is an empty set of braces, and you can nest dictionaries by simply coding one as a value inside another dictionary, or within a list or tuple. 4. As for lists, you might not see dictionaries coded in full using literals very often—programs rarely know all their data before they are run, and more typically extract it dynamically from users, files, and so on. Lists and dictionaries are grown in different ways, though. In the next section you’ll see that you often build up dictionaries by assigning to new keys at runtime; this approach fails for lists, which are commonly grown with append or extend instead. Dictionaries | 251
- 304. Table 8-2. Common dictionary literals and operations Operation Interpretation D = {} Empty dictionary D = {'name': 'Bob', 'age': 40} Two-item dictionary E = {'cto': {'name': 'Bob', 'age': 40}} Nesting D = dict(name='Bob', age=40) D = dict([('name', 'Bob'), ('age', 40)]) D = dict(zip(keyslist, valueslist)) D = dict.fromkeys(['name', 'age']) Alternative construction techniques: keywords, key/value pairs, zipped key/value pairs, key lists D['name'] E['cto']['age'] Indexing by key 'age' in D Membership: key present test D.keys() D.values() D.items() D.copy() D.clear() D.update(D2) D.get(key, default?) D.pop(key, default?) D.setdefault(key, default?) D.popitem() Methods: all keys, all values, all key+value tuples, copy (top-level), clear (remove all items), merge by keys, fetch by key, if absent default (or None), remove by key, if absent default (or error) fetch by key, if absent set default (or None), remove/return any (key, value) pair; etc. len(D) Length: number of stored entries D[key] = 42 Adding/changing keys del D[key] Deleting entries by key list(D.keys()) D1.keys() & D2.keys() Dictionary views (Python 3.X) D.viewkeys(), D.viewvalues() Dictionary views (Python 2.7) D = {x: x*2 for x in range(10)} Dictionary comprehensions (Python 3.X, 2.7) Dictionaries in Action As Table 8-2 suggests, dictionaries are indexed by key, and nested dictionary entries are referenced by a series of indexes (keys in square brackets). When Python creates a dictionary, it stores its items in any left-to-right order it chooses; to fetch a value back, 252 | Chapter 8: Lists and Dictionaries
- 305. you supply the key with which it is associated, not its relative position. Let’s go back to the interpreter to get a feel for some of the dictionary operations in Table 8-2. Basic Dictionary Operations In normal operation, you create dictionaries with literals and store and access items by key with indexing: % python >>> D = {'spam': 2, 'ham': 1, 'eggs': 3} # Make a dictionary >>> D['spam'] # Fetch a value by key 2 >>> D # Order is "scrambled" {'eggs': 3, 'spam': 2, 'ham': 1} Here, the dictionary is assigned to the variable D; the value of the key 'spam' is the integer 2, and so on. We use the same square bracket syntax to index dictionaries by key as we did to index lists by offset, but here it means access by key, not by position. Notice the end of this example—much like sets, the left-to-right order of keys in a dictionary will almost always be different from what you originally typed. This is on purpose: to implement fast key lookup (a.k.a. hashing), keys need to be reordered in memory. That’s why operations that assume a fixed left-to-right order (e.g., slicing, concatenation) do not apply to dictionaries; you can fetch values only by key, not by position. Technically, the ordering is pseudo-random—it’s not truly random (you might be able to decipher it given Python’s source code and a lot of time to kill), but it’s arbitrary, and might vary per release and platform, and even per interactive session in Python 3.3. The built-in len function works on dictionaries, too; it returns the number of items stored in the dictionary or, equivalently, the length of its keys list. The dictionary in membership operator allows you to test for key existence, and the keys method returns all the keys in the dictionary. The latter of these can be useful for processing dictionaries sequentially, but you shouldn’t depend on the order of the keys list. Because the keys result can be used as a normal list, however, it can always be sorted if order matters (more on sorting and dictionaries later): >>> len(D) # Number of entries in dictionary 3 >>> 'ham' in D # Key membership test alternative True >>> list(D.keys()) # Create a new list of D's keys ['eggs', 'spam', 'ham'] Observe the second expression in this listing. As mentioned earlier, the in membership test used for strings and lists also works on dictionaries—it checks whether a key is stored in the dictionary. Technically, this works because dictionaries define iterators that step through their keys lists automatically. Other types provide iterators that reflect Dictionaries in Action | 253
- 306. their common uses; files, for example, have iterators that read line by line. We’ll discuss iterators more formally in Chapter 14 and Chapter 20. Also note the syntax of the last example in this listing. We have to enclose it in a list call in Python 3.X for similar reasons—keys in 3.X returns an iterable object, instead of a physical list. The list call forces it to produce all its values at once so we can print them interactively, though this call isn’t required some other contexts. In 2.X, keys builds and returns an actual list, so the list call isn’t even needed to display a result; more on this later in this chapter. Changing Dictionaries in Place Let’s continue with our interactive session. Dictionaries, like lists, are mutable, so you can change, expand, and shrink them in place without making new dictionaries: simply assign a value to a key to change or create an entry. The del statement works here, too; it deletes the entry associated with the key specified as an index. Notice also the nesting of a list inside a dictionary in this example (the value of the key 'ham'). All collection data types in Python can nest inside each other arbitrarily: >>> D {'eggs': 3, 'spam': 2, 'ham': 1} >>> D['ham'] = ['grill', 'bake', 'fry'] # Change entry (value=list) >>> D {'eggs': 3, 'spam': 2, 'ham': ['grill', 'bake', 'fry']} >>> del D['eggs'] # Delete entry >>> D {'spam': 2, 'ham': ['grill', 'bake', 'fry']} >>> D['brunch'] = 'Bacon' # Add new entry >>> D {'brunch': 'Bacon', 'spam': 2, 'ham': ['grill', 'bake', 'fry']} Like lists, assigning to an existing index in a dictionary changes its associated value. Unlike lists, however, whenever you assign a new dictionary key (one that hasn’t been assigned before) you create a new entry in the dictionary, as was done in the previous example for the key 'brunch'. This doesn’t work for lists because you can only assign to existing list offsets—Python considers an offset beyond the end of a list out of bounds and raises an error. To expand a list, you need to use tools such as the append method or slice assignment instead. More Dictionary Methods Dictionary methods provide a variety of type-specific tools. For instance, the dictionary values and items methods return all of the dictionary’s values and (key,value) pair tuples, respectively; along with keys, these are useful in loops that need to step through dictionary entries one by one (we’ll start coding examples of such loops in the next 254 | Chapter 8: Lists and Dictionaries
- 307. section). As for keys, these two methods also return iterable objects in 3.X, so wrap them in a list call there to collect their values all at once for display: >>> D = {'spam': 2, 'ham': 1, 'eggs': 3} >>> list(D.values()) [3, 2, 1] >>> list(D.items()) [('eggs', 3), ('spam', 2), ('ham', 1)] In realistic programs that gather data as they run, you often won’t be able to predict what will be in a dictionary before the program is launched, much less when it’s coded. Fetching a nonexistent key is normally an error, but the get method returns a default value—None, or a passed-in default—if the key doesn’t exist. It’s an easy way to fill in a default for a key that isn’t present, and avoid a missing-key error when your program can’t anticipate contents ahead of time: >>> D.get('spam') # A key that is there 2 >>> print(D.get('toast')) # A key that is missing None >>> D.get('toast', 88) 88 The update method provides something similar to concatenation for dictionaries, though it has nothing to do with left-to-right ordering (again, there is no such thing in dictionaries). It merges the keys and values of one dictionary into another, blindly overwriting values of the same key if there’s a clash: >>> D {'eggs': 3, 'spam': 2, 'ham': 1} >>> D2 = {'toast':4, 'muffin':5} # Lots of delicious scrambled order here >>> D.update(D2) >>> D {'eggs': 3, 'muffin': 5, 'toast': 4, 'spam': 2, 'ham': 1} Notice how mixed up the key order is in the last result; again, that’s just how diction- aries work. Finally, the dictionary pop method deletes a key from a dictionary and re- turns the value it had. It’s similar to the list pop method, but it takes a key instead of an optional position: # pop a dictionary by key >>> D {'eggs': 3, 'muffin': 5, 'toast': 4, 'spam': 2, 'ham': 1} >>> D.pop('muffin') 5 >>> D.pop('toast') # Delete and return from a key 4 >>> D {'eggs': 3, 'spam': 2, 'ham': 1} # pop a list by position >>> L = ['aa', 'bb', 'cc', 'dd'] >>> L.pop() # Delete and return from the end 'dd' Dictionaries in Action | 255
- 308. >>> L ['aa', 'bb', 'cc'] >>> L.pop(1) # Delete from a specific position 'bb' >>> L ['aa', 'cc'] Dictionaries also provide a copy method; we’ll revisit this in Chapter 9, as it’s a way to avoid the potential side effects of shared references to the same dictionary. In fact, dictionaries come with more methods than those listed in Table 8-2; see the Python library manual, dir and help, or other reference sources for a comprehensive list. Your dictionary ordering may vary: Don’t be alarmed if your dictionaries print in a different order than shown here. As mentioned, key order is arbitrary, and might vary per release, platform, and interactive session in 3.3 (and quite possibly per day of the week, and phase of the moon!). Most of the dictionary examples in this book reflect Python 3.3’s key ordering, but it has changed both since and prior to 3.0. Your Python’s key order may vary, but you’re not supposed to care anyhow: diction- aries are processed by key, not position. Programs shouldn’t rely on the arbitrary order of keys in dictionaries, even if shown in books. There are extension types in Python’s standard library that maintain insertion order among their keys—see OrderedDict in the collections module—but they are hybrids that incur extra space and speed over- headstoachievetheirextrautility,andarenottruedictionaries.Inshort, keys are kept redundantly in a linked list to support sequence opera- tions. As we’ll see in Chapter 9, this module also implements a namedtuple that allows tuple items to be accessed by both attribute name and sequence position—a sort of tuple/class/dictionary hybrid that adds processing steps and is not a core object type in any event. Python’s library manual has the full story on these and other extension types. Example: Movie Database Let’s look at a more realistic dictionary example. In honor of Python’s namesake, the following example creates a simple in-memory Monty Python movie database, as a table that maps movie release date years (the keys) to movie titles (the values). As coded, you fetch movie names by indexing on release year strings: >>> table = {'1975': 'Holy Grail', # Key: Value ... '1979': 'Life of Brian', ... '1983': 'The Meaning of Life'} >>> >>> year = '1983' >>> movie = table[year] # dictionary[Key] => Value >>> movie 'The Meaning of Life' 256 | Chapter 8: Lists and Dictionaries
- 309. >>> for year in table: # Same as: for year in table.keys() ... print(year + 't' + table[year]) ... 1979 Life of Brian 1975 Holy Grail 1983 The Meaning of Life The last command uses a for loop, which we previewed in Chapter 4 but haven’t cov- ered in detail yet. If you aren’t familiar with for loops, this command simply iterates through each key in the table and prints a tab-separated list of keys and their values. We’ll learn more about for loops in Chapter 13. Dictionaries aren’t sequences like lists and strings, but if you need to step through the items in a dictionary, it’s easy—calling the dictionary keys method returns all stored keys, which you can iterate through with a for. If needed, you can index from key to value inside the for loop as you go, as was done in this code. In fact, Python also lets you step through a dictionary’s keys list without actually calling the keys method in most for loops. For any dictionary D, saying for key in D works the same as saying the completefor key in D.keys(). This is really just another instance of the iterators mentioned earlier, which allow the in membership operator to work on dictionaries as well; more on iterators later in this book. Preview: Mapping values to keys Notice how the prior table maps year to titles, but not vice versa. If you want to map the other way—titles to years—you can either code the dictionary differently, or use methods like items that give searchable sequences, though using them to best effect requires more background information than we yet have: >>> table = {'Holy Grail': '1975', # Key=>Value (title=>year) ... 'Life of Brian': '1979', ... 'The Meaning of Life': '1983'} >>> >>> table['Holy Grail'] '1975' >>> list(table.items()) # Value=>Key (year=>title) [('The Meaning of Life', '1983'), ('Holy Grail', '1975'), ('Life of Brian', '1979')] >>> [title for (title, year) in table.items() if year == '1975'] ['Holy Grail'] The last command here is in part a preview for the comprehension syntax introduced in Chapter 4 and covered in full in Chapter 14. In short, it scans the dictionary’s (key, value) tuple pairs returned by the items method, selecting keys having a specified value. The net effect is to index backward—from value to key, instead of key to value—useful if you want to store data just once and map backward only rarely (searching through sequences like this is generally much slower than a direct key index). Dictionaries in Action | 257
- 310. In fact, although dictionaries by nature map keys to values unidirectionally, there are multiple ways to map values back to keys with a bit of extra generalizable code: >>> K = 'Holy Grail' >>> table[K] # Key=>Value (normal usage) '1975' >>> V = '1975' >>> [key for (key, value) in table.items() if value == V] # Value=>Key ['Holy Grail'] >>> [key for key in table.keys() if table[key] == V] # Ditto ['Holy Grail'] Note that both of the last two commands return a list of titles: in dictionaries, there’s just one value per key, but there may be many keys per value. A given value may be stored under multiple keys (yielding multiple keys per value), and a value might be a collection itself (supporting multiple values per key). For more on this front, also watch for a dictionary inversion function in Chapter 32’s mapattrs.py example—code that would surely stretch this preview past its breaking point if included here. For this chapter’s purposes, let’s explore more dictionary basics. Dictionary Usage Notes Dictionaries are fairly straightforward tools once you get the hang of them, but here are a few additional pointers and reminders you should be aware of when using them: • Sequence operations don’t work. Dictionaries are mappings, not sequences; be- cause there’s no notion of ordering among their items, things like concatenation (an ordered joining) and slicing (extracting a contiguous section) simply don’t ap- ply. In fact, Python raises an error when your code runs if you try to do such things. • Assigning to new indexes adds entries. Keys can be created when you write a dictionary literal (embedded in the code of the literal itself), or when you assign values to new keys of an existing dictionary object individually. The end result is the same. • Keys need not always be strings. Our examples so far have used strings as keys, but any other immutable objects work just as well. For instance, you can use inte- gers as keys, which makes the dictionary look much like a list (when indexing, at least). Tuples may be used as dictionary keys too, allowing compound key values —such as dates and IP addresses—to have associated values. User-defined class instance objects (discussed in Part VI) can also be used as keys, as long as they have the proper protocol methods; roughly, they need to tell Python that their values are “hashable” and thus won’t change, as otherwise they would be useless as fixed keys. Mutable objects such as lists, sets, and other dictionaries don’t work as keys, but are allowed as values. 258 | Chapter 8: Lists and Dictionaries
- 311. Using dictionaries to simulate flexible lists: Integer keys The last point in the prior list is important enough to demonstrate with a few examples. When you use lists, it is illegal to assign to an offset that is off the end of the list: >>> L = [] >>> L[99] = 'spam' Traceback (most recent call last): File "<stdin>", line 1, in ? IndexError: list assignment index out of range Although you can use repetition to preallocate as big a list as you’ll need (e.g., [0]*100), you can also do something that looks similar with dictionaries that does not require such space allocations. By using integer keys, dictionaries can emulate lists that seem to grow on offset assignment: >>> D = {} >>> D[99] = 'spam' >>> D[99] 'spam' >>> D {99: 'spam'} Here, it looks as if D is a 100-item list, but it’s really a dictionary with a single entry; the value of the key 99 is the string 'spam'. You can access this structure with offsets much like a list, catching nonexistent keys with get or in tests if required, but you don’t have to allocate space for all the positions you might ever need to assign values to in the future. When used like this, dictionaries are like more flexible equivalents of lists. As another example, we might also employ integer keys in our first movie database’s code earlier to avoid quoting the year, albeit at the expense of some expressiveness (keys cannot contain nondigit characters): >>> table = {1975: 'Holy Grail', ... 1979: 'Life of Brian', # Keys are integers, not strings ... 1983: 'The Meaning of Life'} >>> table[1975] 'Holy Grail' >>> list(table.items()) [(1979, 'Life of Brian'), (1983, 'The Meaning of Life'), (1975, 'Holy Grail')] Using dictionaries for sparse data structures: Tuple keys In a similar way, dictionary keys are also commonly leveraged to implement sparse data structures—for example, multidimensional arrays where only a few positions have val- ues stored in them: >>> Matrix = {} >>> Matrix[(2, 3, 4)] = 88 >>> Matrix[(7, 8, 9)] = 99 >>> >>> X = 2; Y = 3; Z = 4 # ; separates statements: see Chapter 10 >>> Matrix[(X, Y, Z)] 88 Dictionaries in Action | 259
- 312. >>> Matrix {(2, 3, 4): 88, (7, 8, 9): 99} Here, we’ve used a dictionary to represent a three-dimensional array that is empty except for the two positions (2,3,4) and (7,8,9). The keys are tuples that record the coordinates of nonempty slots. Rather than allocating a large and mostly empty three- dimensional matrix to hold these values, we can use a simple two-item dictionary. In this scheme, accessing an empty slot triggers a nonexistent key exception, as these slots are not physically stored: >>> Matrix[(2,3,6)] Traceback (most recent call last): File "<stdin>", line 1, in ? KeyError: (2, 3, 6) Avoiding missing-key errors Errors for nonexistent key fetches are common in sparse matrixes, but you probably won’t want them to shut down your program. There are at least three ways to fill in a default value instead of getting such an error message—you can test for keys ahead of time in if statements, use a try statement to catch and recover from the exception explicitly, or simply use the dictionary get method shown earlier to provide a default for keys that do not exist. Consider the first two of these previews for statement syntax we’ll begin studying in Chapter 10: >>> if (2, 3, 6) in Matrix: # Check for key before fetch ... print(Matrix[(2, 3, 6)]) # See Chapters 10 and 12 for if/else ... else: ... print(0) ... 0 >>> try: ... print(Matrix[(2, 3, 6)]) # Try to index ... except KeyError: # Catch and recover ... print(0) # See Chapters 10 and 34 for try/except ... 0 >>> Matrix.get((2, 3, 4), 0) # Exists: fetch and return 88 >>> Matrix.get((2, 3, 6), 0) # Doesn't exist: use default arg 0 Of these, the get method is the most concise in terms of coding requirements, but the if and try statements are much more general in scope; again, more on these starting in Chapter 10. Nesting in dictionaries As you can see, dictionaries can play many roles in Python. In general, they can replace search data structures (because indexing by key is a search operation) and can represent many types of structured information. For example, dictionaries are one of many ways 260 | Chapter 8: Lists and Dictionaries
- 313. to describe the properties of an item in your program’s domain; that is, they can serve the same role as “records” or “structs” in other languages. The following, for example, fills out a dictionary describing a hypothetical person, by assigning to new keys over time (if you are a Bob, my apologies for picking on your name in this book—it’s easy to type!): >>> rec = {} >>> rec['name'] = 'Bob' >>> rec['age'] = 40.5 >>> rec['job'] = 'developer/manager' >>> >>> print(rec['name']) Bob Especially when nested, Python’s built-in data types allow us to easily represent struc- tured information. The following again uses a dictionary to capture object properties, but it codes it all at once (rather than assigning to each key separately) and nests a list and a dictionary to represent structured property values: >>> rec = {'name': 'Bob', ... 'jobs': ['developer', 'manager'], ... 'web': 'www.bobs.org/˜Bob', ... 'home': {'state': 'Overworked', 'zip': 12345}} To fetch components of nested objects, simply string together indexing operations: >>> rec['name'] 'Bob' >>> rec['jobs'] ['developer', 'manager'] >>> rec['jobs'][1] 'manager' >>> rec['home']['zip'] 12345 Although we’ll learn in Part VI that classes (which group both data and logic) can be better in this record role, dictionaries are an easy-to-use tool for simpler requirements. For more on record representation choices, see also the upcoming sidebar “Why You Will Care: Dictionaries Versus Lists” on page 263, as well as its extension to tuples in Chapter 9 and classes in Chapter 27. Also notice that while we’ve focused on a single “record” with nested data here, there’s no reason we couldn’t nest the record itself in a larger, enclosing database collection coded as a list or dictionary, though an external file or formal database interface often plays the role of top-level container in realistic programs: db = [] db.append(rec) # A list "database" db.append(other) db[0]['jobs'] db = {} db['bob'] = rec # A dictionary "database" Dictionaries in Action | 261
- 314. db['sue'] = other db['bob']['jobs'] Later in the book we’ll meet tools such as Python’s shelve, which works much the same way, but automatically maps objects to and from files to make them permanent (watch for more in this chapter’s sidebar “Why You Will Care: Dictionary Inter- faces” on page 271). Other Ways to Make Dictionaries Finally, note that because dictionaries are so useful, more ways to build them have emerged over time. In Python 2.3 and later, for example, the last two calls to the dict constructor (really, type name) shown here have the same effect as the literal and key- assignment forms above them: {'name': 'Bob', 'age': 40} # Traditional literal expression D = {} # Assign by keys dynamically D['name'] = 'Bob' D['age'] = 40 dict(name='Bob', age=40) # dict keyword argument form dict([('name', 'Bob'), ('age', 40)]) # dict key/value tuples form All four of these forms create the same two-key dictionary, but they are useful in dif- fering circumstances: • The first is handy if you can spell out the entire dictionary ahead of time. • The second is of use if you need to create the dictionary one field at a time on the fly. • The third involves less typing than the first, but it requires all keys to be strings. • The last is useful if you need to build up keys and values as sequences at runtime. We met keyword arguments earlier when sorting; the third form illustrated in this code listing has become especially popular in Python code today, since it has less syntax (and hence there is less opportunity for mistakes). As suggested previously in Table 8-2, the last form in the listing is also commonly used in conjunction with the zip function, to combine separate lists of keys and values obtained dynamically at runtime (parsed out of a data file’s columns, for instance): dict(zip(keyslist, valueslist)) # Zipped key/value tuples form (ahead) More on zipping dictionary keys in the next section. Provided all the key’s values are the same initially, you can also create a dictionary with this special form—simply pass in a list of keys and an initial value for all of the values (the default is None): >>> dict.fromkeys(['a', 'b'], 0) {'a': 0, 'b': 0} 262 | Chapter 8: Lists and Dictionaries
- 315. Although you could get by with just literals and key assignments at this point in your Python career, you’ll probably find uses for all of these dictionary-creation forms as you start applying them in realistic, flexible, and dynamic Python programs. The listings in this section document the various ways to create dictionaries in both Python 2.X and 3.X. However, there is yet another way to create dictionaries, available only in Python 3.X and 2.7: the dictionary comprehension expression. To see how this last form looks, we need to move on to the next and final section of this chapter. Why You Will Care: Dictionaries Versus Lists With all the objects in Python’s core types arsenal, some readers may be puzzled over the choice between lists and dictionaries. In short, although both are flexible collections of other objects, lists assign items to positions, and dictionaries assign them to more mnemonic keys. Because of this, dictionary data often carries more meaning to human readers. For example, the nested list structure in row 3 of Table 8-1 could be used to represent a record too: >>> L = ['Bob', 40.5, ['dev', 'mgr']] # List-based "record" >>> L[0] 'Bob' >>> L[1] # Positions/numbers for fields 40.5 >>> L[2][1] 'mgr' For some types of data, the list’s access-by-position makes sense—a list of employees in a company, the files in a directory, or numeric matrixes, for example. But a more symbolic record like this may be more meaningfully coded as a dictionary along the lines of row 2 in Table 8-2, with labeled fields replacing field positions (this is similar to a record we coded in Chapter 4): >>> D = {'name': 'Bob', 'age': 40.5, 'jobs': ['dev', 'mgr']} >>> D['name'] 'Bob' >>> D['age'] # Dictionary-based "record" 40.5 >>> D['jobs'][1] # Names mean more than numbers 'mgr' For variety, here is the same record recoded with keywords, which may seem even more readable to some human readers: >>> D = dict(name='Bob', age=40.5, jobs=['dev', 'mgr']) >>> D['name'] 'Bob' >>> D['jobs'].remove('mgr') >>> D {'jobs': ['dev'], 'age': 40.5, 'name': 'Bob'} In practice, dictionaries tend to be best for data with labeled components, as well as structures that can benefit from quick, direct lookups by name, instead of slower linear searches. As we’ve seen, they also may be better for sparse collections and collections that grow at arbitrary positions. Dictionaries in Action | 263
- 316. Python programmers also have access to the sets we studied in Chapter 5, which are much like the keys of a valueless dictionary; they don’t map keys to values, but can often be used like dictionaries for fast lookups when there is no associated value, es- pecially in search routines: >>> D = {} >>> D['state1'] = True # A visited-state dictionary >>> 'state1' in D True >>> S = set() >>> S.add('state1') # Same, but with sets >>> 'state1' in S True Watch for a rehash of this record representation thread in the next chapter, where we’ll see how tuples and named tuples compare to dictionaries in this role, as well as in Chapter 27, where we’ll learn how user-defined classes factor into this picture, com- bining both data and logic to process it. Dictionary Changes in Python 3.X and 2.7 This chapter has so far focused on dictionary basics that span releases, but the dictio- nary’s functionality has mutated in Python 3.X. If you are using Python 2.X code, you may come across some dictionary tools that either behave differently or are missing altogether in 3.X. Moreover, 3.X coders have access to additional dictionary tools not available in 2.X, apart from two back-ports to 2.7. Specifically, dictionaries in Python 3.X: • Support a new dictionary comprehension expression, a close cousin to list and set comprehensions • Return set-like iterable views instead of lists for the methods D.keys, D.values, and D.items • Require new coding styles for scanning by sorted keys, because of the prior point • No longer support relative magnitude comparisons directly—compare manually instead • No longer have the D.has_key method—the in membership test is used instead As later back-ports from 3.X, dictionaries in Python 2.7 (but not earlier in 2.X): • Support item 1 in the prior list—dictionary comprehensions—as a direct back-port from 3.X • Support item 2 in the prior list—set-like iterable views—but do so with special method names D.viewkeys, D.viewvalues, D.viewitems); their nonview methods return lists as before 264 | Chapter 8: Lists and Dictionaries
- 317. Because of this overlap, some of the material in this section pertains both to 3.X and 2.7, but is presented here in the context of 3.X extensions because of its origin. With that in mind, let’s take a look at what’s new in dictionaries in 3.X and 2.7. Dictionary comprehensions in 3.X and 2.7 As mentioned at the end of the prior section, dictionaries in 3.X and 2.7 can also be created with dictionary comprehensions. Like the set comprehensions we met in Chapter 5, dictionary comprehensions are available only in 3.X and 2.7 (not in 2.6 and earlier). Like the longstanding list comprehensions we met briefly in Chapter 4 and earlier in this chapter, they run an implied loop, collecting the key/value results of expressions on each iteration and using them to fill out a new dictionary. A loop variable allows the comprehension to use loop iteration values along the way. To illustrate, a standard way to initialize a dictionary dynamically in both 2.X and 3.X is to combine its keys and values with zip, and pass the result to the dict call. The zip built-in function is the hook that allows us to construct a dictionary from key and value lists this way—if you cannot predict the set of keys and values in your code, you can always build them up as lists and zip them together. We’ll study zip in detail in Chapter 13 and Chapter 14 after exploring statements; it’s an iterable in 3.X, so we must wrap it in a list call to show its results there, but its basic usage is otherwise straightforward: >>> list(zip(['a', 'b', 'c'], [1, 2, 3])) # Zip together keys and values [('a', 1), ('b', 2), ('c', 3)] >>> D = dict(zip(['a', 'b', 'c'], [1, 2, 3])) # Make a dict from zip result >>> D {'b': 2, 'c': 3, 'a': 1} In Python 3.X and 2.7, though, you can achieve the same effect with a dictionary com- prehension expression. The following builds a new dictionary with a key/value pair for every such pair in the zip result (it reads almost the same in Python, but with a bit more formality): >>> D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])} >>> D {'b': 2, 'c': 3, 'a': 1} Comprehensions actually require more code in this case, but they are also more general than this example implies—we can use them to map a single stream of values to dic- tionaries as well, and keys can be computed with expressions just like values: >>> D = {x: x ** 2 for x in [1, 2, 3, 4]} # Or: range(1, 5) >>> D {1: 1, 2: 4, 3: 9, 4: 16} >>> D = {c: c * 4 for c in 'SPAM'} # Loop over any iterable >>> D {'S': 'SSSS', 'P': 'PPPP', 'A': 'AAAA', 'M': 'MMMM'} Dictionaries in Action | 265
- 318. >>> D = {c.lower(): c + '!' for c in ['SPAM', 'EGGS', 'HAM']} >>> D {'eggs': 'EGGS!', 'spam': 'SPAM!', 'ham': 'HAM!'} Dictionary comprehensions are also useful for initializing dictionaries from keys lists, in much the same way as the fromkeys method we met at the end of the preceding section: >>> D = dict.fromkeys(['a', 'b', 'c'], 0) # Initialize dict from keys >>> D {'b': 0, 'c': 0, 'a': 0} >>> D = {k:0 for k in ['a', 'b', 'c']} # Same, but with a comprehension >>> D {'b': 0, 'c': 0, 'a': 0} >>> D = dict.fromkeys('spam') # Other iterables, default value >>> D {'s': None, 'p': None, 'a': None, 'm': None} >>> D = {k: None for k in 'spam'} >>> D {'s': None, 'p': None, 'a': None, 'm': None} Like related tools, dictionary comprehensions support additional syntax not shown here, including nested loops and if clauses. Unfortunately, to truly understand dictio- nary comprehensions, we need to also know more about iteration statements and con- cepts in Python, and we don’t yet have enough information to address that story well. We’ll learn much more about all flavors of comprehensions (list, set, dictionary, and generator) in Chapter 14 and Chapter 20, so we’ll defer further details until later. We’ll also revisit the zip built-in we used in this section in more detail in Chapter 13, when we explore for loops. Dictionary views in 3.X (and 2.7 via new methods) In 3.X the dictionary keys, values, and items methods all return view objects, whereas in 2.X they return actual result lists. This functionality is also available in Python 2.7, but in the guise of the special, distinct method names listed at the start of this section (2.7’s normal methods still return simple lists, so as to avoid breaking existing 2.X code); because of this, I’ll refer to this as a 3.X feature in this section. View objects are iterables, which simply means objects that generate result items one at a time, instead of producing the result list all at once in memory. Besides being iterable, dictionary views also retain the original order of dictionary components, reflect future changes to the dictionary, and may support set operations. On the other hand, because they are not lists, they do not directly support operations like indexing or the list sort method, and do not display their items as a normal list when printed (they do show their components as of Python 3.1 but not as a list, and are still a divergence from 2.X). 266 | Chapter 8: Lists and Dictionaries
- 319. We’ll discuss the notion of iterables more formally in Chapter 14, but for our purposes here it’s enough to know that we have to run the results of these three methods through the list built-in if we want to apply list operations or display their values. For example, in Python 3.3 (other version’s outputs may differ slightly): >>> D = dict(a=1, b=2, c=3) >>> D {'b': 2, 'c': 3, 'a': 1} >>> K = D.keys() # Makes a view object in 3.X, not a list >>> K dict_keys(['b', 'c', 'a']) >>> list(K) # Force a real list in 3.X if needed ['b', 'c', 'a'] >>> V = D.values() # Ditto for values and items views >>> V dict_values([2, 3, 1]) >>> list(V) [2, 3, 1] >>> D.items() dict_items([('b', 2), ('c', 3), ('a', 1)]) >>> list(D.items()) [('b', 2), ('c', 3), ('a', 1)] >>> K[0] # List operations fail unless converted TypeError: 'dict_keys' object does not support indexing >>> list(K)[0] 'b' Apart from result displays at the interactive prompt, you will probably rarely even notice this change, because looping constructs in Python automatically force iterable objects to produce one result on each iteration: >>> for k in D.keys(): print(k) # Iterators used automatically in loops ... b c a In addition, 3.X dictionaries still have iterators themselves, which return successive keys—as in 2.X, it’s still often not necessary to call keys directly: >>> for key in D: print(key) # Still no need to call keys() to iterate ... b c a Unlike 2.X’s list results, though, dictionary views in 3.X are not carved in stone when created—they dynamically reflect future changes made to the dictionary after the view object has been created: Dictionaries in Action | 267
- 320. >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D {'b': 2, 'c': 3, 'a': 1} >>> K = D.keys() >>> V = D.values() >>> list(K) # Views maintain same order as dictionary ['b', 'c', 'a'] >>> list(V) [2, 3, 1] >>> del D['b'] # Change the dictionary in place >>> D {'c': 3, 'a': 1} >>> list(K) # Reflected in any current view objects ['c', 'a'] >>> list(V) # Not true in 2.X! - lists detached from dict [3, 1] Dictionary views and sets Also unlike 2.X’s list results, 3.X’s view objects returned by the keys method are set- like and support common set operations such as intersection and union; values views are not set-like, but items results are if their (key, value) pairs are unique and hashable (immutable). Given that sets behave much like valueless dictionaries (and may even be coded in curly braces like dictionaries in 3.X and 2.7), this is a logical symmetry. Per Chapter 5, set items are unordered, unique, and immutable, just like dictionary keys. Here is what keys views look like when used in set operations (continuing the prior section’s session); dictionary value views are never set-like, since their items are not necessarily unique or immutable: >>> K, V (dict_keys(['c', 'a']), dict_values([3, 1])) >>> K | {'x': 4} # Keys (and some items) views are set-like {'c', 'x', 'a'} >>> V & {'x': 4} TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict' >>> V & {'x': 4}.values() TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict_values' In set operations, views may be mixed with other views, sets, and dictionaries; dic- tionaries are treated the same as their keys views in this context: >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D.keys() & D.keys() # Intersect keys views {'b', 'c', 'a'} >>> D.keys() & {'b'} # Intersect keys and set {'b'} >>> D.keys() & {'b': 1} # Intersect keys and dict {'b'} 268 | Chapter 8: Lists and Dictionaries
- 321. >>> D.keys() | {'b', 'c', 'd'} # Union keys and set {'b', 'c', 'a', 'd'} Items views are set-like too if they are hashable—that is, if they contain only immutable objects: >>> D = {'a': 1} >>> list(D.items()) # Items set-like if hashable [('a', 1)] >>> D.items() | D.keys() # Union view and view {('a', 1), 'a'} >>> D.items() | D # dict treated same as its keys {('a', 1), 'a'} >>> D.items() | {('c', 3), ('d', 4)} # Set of key/value pairs {('d', 4), ('a', 1), ('c', 3)} >>> dict(D.items() | {('c', 3), ('d', 4)}) # dict accepts iterable sets too {'c': 3, 'a': 1, 'd': 4} See Chapter 5’s coverage of sets if you need a refresher on these operations. Here, let’s wrap up with three other quick coding notes for 3.X dictionaries. Sorting dictionary keys in 3.X First of all, because keys does not return a list in 3.X, the traditional coding pattern for scanning a dictionary by sorted keys in 2.X won’t work in 3.X: >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D {'b': 2, 'c': 3, 'a': 1} >>> Ks = D.keys() # Sorting a view object doesn't work! >>> Ks.sort() AttributeError: 'dict_keys' object has no attribute 'sort' To work around this, in 3.X you must either convert to a list manually or use the sorted call (introduced in Chapter 4 and covered in this chapter) on either a keys view or the dictionary itself: >>> Ks = list(Ks) # Force it to be a list and then sort >>> Ks.sort() >>> for k in Ks: print(k, D[k]) # 2.X: omit outer parens in prints ... a 1 b 2 c 3 >>> D {'b': 2, 'c': 3, 'a': 1} >>> Ks = D.keys() # Or you can use sorted() on the keys >>> for k in sorted(Ks): print(k, D[k]) # sorted() accepts any iterable ... # sorted() returns its result a 1 Dictionaries in Action | 269
- 322. b 2 c 3 Of these, using the dictionary’s keys iterator is probably preferable in 3.X, and works in 2.X as well: >>> D {'b': 2, 'c': 3, 'a': 1} # Better yet, sort the dict directly >>> for k in sorted(D): print(k, D[k]) # dict iterators return keys ... a 1 b 2 c 3 Dictionary magnitude comparisons no longer work in 3.X Secondly, while in Python 2.X dictionaries may be compared for relative magnitude directly with <, >, and so on, in Python 3.X this no longer works. However, you can simulate it by comparing sorted keys lists manually: sorted(D1.items()) < sorted(D2.items()) # Like 2.X D1 < D2 Dictionary equality tests (e.g., D1 == D2) still work in 3.X, though. Since we’ll revisit this near the end of the next chapter in the context of comparisons at large, we’ll post- pone further details here. The has_key method is dead in 3.X: Long live in! Finally, the widely used dictionary has_key key presence test method is gone in 3.X. Instead, use the in membership expression, or a get with a default test (of these, in is generally preferred): >>> D {'b': 2, 'c': 3, 'a': 1} >>> D.has_key('c') # 2.X only: True/False AttributeError: 'dict' object has no attribute 'has_key' >>> 'c' in D # Required in 3.X True >>> 'x' in D # Preferred in 2.X today False >>> if 'c' in D: print('present', D['c']) # Branch on result ... present 3 >>> print(D.get('c')) # Fetch with default 3 >>> print(D.get('x')) None >>> if D.get('c') != None: print('present', D['c']) # Another option ... present 3 270 | Chapter 8: Lists and Dictionaries
- 323. To summarize, the dictionary story changes substantially in 3.X. If you work in 2.X and care about 3.X compatibility (or suspect that you might someday), here are some pointers. Of the 3.X changes we’ve met in this section: • The first (dictionary comprehensions) can be coded only in 3.X and 2.7. • The second (dictionary views) can be coded only in 3.X, and with special method names in 2.7. However, the last three techniques—sorted, manual comparisons, and in—can be coded in 2.X today to ease 3.X migration in the future. Why You Will Care: Dictionary Interfaces Dictionaries aren’t just a convenient way to store information by key in your programs —some Python extensions also present interfaces that look like and work the same as dictionaries. For instance, Python’s interface to DBM access-by-key files looks much like a dictionary that must be opened. You store and fetch strings using key indexes: import dbm # Named anydbm in Python 2.X file = dbm.open("filename") # Link to file file['key'] = 'data' # Store data by key data = file['key'] # Fetch data by key In Chapter 28, you’ll see that you can store entire Python objects this way, too, if you replace dbm in the preceding code with shelve (shelves are access-by-key databases that store persistent Python objects, not just strings). For Internet work, Python’s CGI script support also presents a dictionary-like interface. A call to cgi.FieldStorage yields a dictionary-like object with one entry per input field on the client’s web page: import cgi form = cgi.FieldStorage() # Parse form data if 'name' in form: showReply('Hello, ' + form['name'].value) Though dictionaries are the only core mapping type, all of these others are instances of mappings, and support most of the same operations. Once you learn dictionary interfaces, you’ll find that they apply to a variety of built-in tools in Python. For another dictionary use case, see also Chapter 9’s upcoming overview of JSON—a language-neutral data format used for databases and data transfer. Python dictionaries, lists, and nested combinations of them can almost pass for records in this format as is, and may be easily translated to and from formal JSON text strings with Python’s json standard library module. Chapter Summary In this chapter, we explored the list and dictionary types—probably the two most common, flexible, and powerful collection types you will see and use in Python code. We learned that the list type supports positionally ordered collections of arbitrary ob- Chapter Summary | 271
- 324. jects, and that it may be freely nested and grown and shrunk on demand. The dictionary type is similar, but it stores items by key instead of by position and does not maintain any reliable left-to-right order among its items. Both lists and dictionaries are mutable, and so support a variety of in-place change operations not available for strings: for example, lists can be grown by append calls, and dictionaries by assignment to new keys. In the next chapter, we will wrap up our in-depth core object type tour by looking at tuplesandfiles.Afterthat,we’llmoveontostatementsthatcodethelogicthatprocesses our objects, taking us another step toward writing complete programs. Before we tackle those topics, though, here are some chapter quiz questions to review. Test Your Knowledge: Quiz 1. Name two ways to build a list containing five integer zeros. 2. Name two ways to build a dictionary with two keys, 'a' and 'b', each having an associated value of 0. 3. Name four operations that change a list object in place. 4. Name four operations that change a dictionary object in place. 5. Why might you use a dictionary instead of a list? Test Your Knowledge: Answers 1. A literal expression like [0, 0, 0, 0, 0] and a repetition expression like [0] * 5 will each create a list of five zeros. In practice, you might also build one up with a loop that starts with an empty list and appends 0 to it in each iteration, with L.append(0). A list comprehension ([0 for i in range(5)]) could work here, too, but this is more work than you need to do for this answer. 2. A literal expression such as {'a': 0, 'b': 0} or a series of assignments like D = {}, D['a'] = 0, and D['b'] = 0 would create the desired dictionary. You can also use the newer and simpler-to-code dict(a=0, b=0) keyword form, or the more flexible dict([('a', 0), ('b', 0)]) key/value sequences form. Or, because all the values are the same, you can use the special form dict.fromkeys('ab', 0). In 3.X and 2.7, you can also use a dictionary comprehension:{k:0 for k in 'ab'}, though again, this may be overkill here. 3. The append and extend methods grow a list in place, the sort and reverse methods order and reverse lists, the insert method inserts an item at an offset, the remove and pop methods delete from a list by value and by position, the del statement deletes an item or slice, and index and slice assignment statements replace an item or entire section. Pick any four of these for the quiz. 4. Dictionaries are primarily changed by assignment to a new or existing key, which creates or changes the key’s entry in the table. Also, the del statement deletes a 272 | Chapter 8: Lists and Dictionaries
- 325. key’s entry, the dictionary update method merges one dictionary into another in place, and D.pop(key) removes a key and returns the value it had. Dictionaries also have other, more exotic in-place change methods not presented in this chapter, such as setdefault; see reference sources for more details. 5. Dictionaries are generally better when the data is labeled (a record with field names, for example); lists are best suited to collections of unlabeled items (such as all the files in a directory). Dictionary lookup is also usually quicker than searching a list, though this might vary per program. Test Your Knowledge: Answers | 273
- 327. CHAPTER 9 Tuples, Files, and Everything Else This chapter rounds out our in-depth tour of the core object types in Python by ex- ploring the tuple, a collection of other objects that cannot be changed, and the file, an interface to external files on your computer. As you’ll see, the tuple is a relatively simple object that largely performs operations you’ve already learned about for strings and lists. The file object is a commonly used and full-featured tool for processing files on your computer. Because files are so pervasive in programming, the basic overview of files here is supplemented by larger examples in later chapters. This chapter also concludes this part of the book by looking at properties common to all the core object types we’ve met—the notions of equality, comparisons, object copies, and so on. We’ll also briefly explore other object types in Python’s toolbox, including the None placeholder and the namedtuple hybrid; as you’ll see, although we’ve covered all the primary built-in types, the object story in Python is broader than I’ve implied thus far. Finally, we’ll close this part of the book by taking a look at a set of common object type pitfalls and exploring some exercises that will allow you to ex- periment with the ideas you’ve learned. This chapter’s scope—files: As in Chapter 7 on strings, our look at files here will be limited in scope to file fundamentals that most Python pro- grammers—including newcomers to programming—need to know. In particular, Unicode text files were previewed in Chapter 4, but we’re going to postpone full coverage of them until Chapter 37, as optional or deferred reading in the Advanced Topics part of this book. For this chapter’s purpose, we’ll assume any text files used will be en- coded and decoded per your platform’s default, which may be UTF-8 on Windows, and ASCII or other elsewhere (and if you don’t know why this matters, you probably don’t need to up front). We’ll also assume that filenames encode properly on the underlying platform, though we’ll stick with ASCII names for portability here. If Unicode text and files is a critical subject for you, I suggest reading the Chapter 4 preview for a quick first look, and continuing on to 275
- 328. Chapter 37 after you master the file basics covered here. For all others, the file coverage here will apply both to typical text and binary files of the sort we’ll meet here, as well as to more advanced file-processing modes you may choose to explore later. Tuples The last collection type in our survey is the Python tuple. Tuples construct simple groups of objects. They work exactly like lists, except that tuples can’t be changed in place (they’re immutable) and are usually written as a series of items in parentheses, not square brackets. Although they don’t support as many methods, tuples share most of their properties with lists. Here’s a quick look at the basics. Tuples are: Ordered collections of arbitrary objects Like strings and lists, tuples are positionally ordered collections of objects (i.e., they maintain a left-to-right order among their contents); like lists, they can embed any kind of object. Accessed by offset Like strings and lists, items in a tuple are accessed by offset (not by key); they support all the offset-based access operations, such as indexing and slicing. Of the category “immutable sequence” Like strings and lists, tuples are sequences; they support many of the same opera- tions. However, like strings, tuples are immutable; they don’t support any of the in-place change operations applied to lists. Fixed-length, heterogeneous, and arbitrarily nestable Because tuples are immutable, you cannot change the size of a tuple without mak- ing a copy. On the other hand, tuples can hold any type of object, including other compound objects (e.g., lists, dictionaries, other tuples), and so support arbitrary nesting. Arrays of object references Like lists, tuples are best thought of as object reference arrays; tuples store access points to other objects (references), and indexing a tuple is relatively quick. Table 9-1 highlights common tuple operations. A tuple is written as a series of objects (technically, expressions that generate objects), separated by commas and normally enclosed in parentheses. An empty tuple is just a parentheses pair with nothing inside. Table 9-1. Common tuple literals and operations Operation Interpretation () An empty tuple T = (0,) A one-item tuple (not an expression) T = (0, 'Ni', 1.2, 3) A four-item tuple T = 0, 'Ni', 1.2, 3 Another four-item tuple (same as prior line) 276 | Chapter 9: Tuples, Files, and Everything Else
- 329. Operation Interpretation T = ('Bob', ('dev', 'mgr')) Nested tuples T = tuple('spam') Tuple of items in an iterable T[i] T[i][j] T[i:j] len(T) Index, index of index, slice, length T1 + T2 T * 3 Concatenate, repeat for x in T: print(x) 'spam' in T [x ** 2 for x in T] Iteration, membership T.index('Ni') T.count('Ni') Methods in 2.6, 2.7, and 3.X: search, count namedtuple('Emp', ['name', 'jobs']) Named tuple extension type Tuples in Action As usual, let’s start an interactive session to explore tuples at work. Notice in Ta- ble 9-1 that tuples do not have all the methods that lists have (e.g., an append call won’t work here). They do, however, support the usual sequence operations that we saw for both strings and lists: >>> (1, 2) + (3, 4) # Concatenation (1, 2, 3, 4) >>> (1, 2) * 4 # Repetition (1, 2, 1, 2, 1, 2, 1, 2) >>> T = (1, 2, 3, 4) # Indexing, slicing >>> T[0], T[1:3] (1, (2, 3)) Tuple syntax peculiarities: Commas and parentheses The second and fourth entries in Table 9-1 merit a bit more explanation. Because parentheses can also enclose expressions (see Chapter 5), you need to do something special to tell Python when a single object in parentheses is a tuple object and not a simple expression. If you really want a single-item tuple, simply add a trailing comma after the single item, before the closing parenthesis: >>> x = (40) # An integer! >>> x 40 Tuples | 277
- 330. >>> y = (40,) # A tuple containing an integer >>> y (40,) As a special case, Python also allows you to omit the opening and closing parentheses for a tuple in contexts where it isn’t syntactically ambiguous to do so. For instance, the fourth line of Table 9-1 simply lists four items separated by commas. In the context of an assignment statement, Python recognizes this as a tuple, even though it doesn’t have parentheses. Now, some people will tell you to always use parentheses in your tuples, and some will tell you to never use parentheses in tuples (and still others have lives, and won’t tell you what to do with your tuples!). The most common places where the parentheses are required for tuple literals are those where: • Parentheses matter—within a function call, or nested in a larger expression. • Commas matter—embedded in the literal of a larger data structure like a list or dictionary, or listed in a Python 2.X print statement. In most other contexts, the enclosing parentheses are optional. For beginners, the best advice is that it’s probably easier to use the parentheses than it is to remember when they are optional or required. Many programmers (myself included) also find that parentheses tend to aid script readability by making the tuples more explicit and ob- vious, but your mileage may vary. Conversions, methods, and immutability Apart from literal syntax differences, tuple operations (the middle rows in Table 9-1) are identical to string and list operations. The only differences worth noting are that the +, *, and slicing operations return new tuples when applied to tuples, and that tuples don’t provide the same methods you saw for strings, lists, and dictionaries. If you want to sort a tuple, for example, you’ll usually have to either first convert it to a list to gain access to a sorting method call and make it a mutable object, or use the newer sorted built-in that accepts any sequence object (and other iterables—a term introduced in Chapter 4 that we’ll be more formal about in the next part of this book): >>> T = ('cc', 'aa', 'dd', 'bb') >>> tmp = list(T) # Make a list from a tuple's items >>> tmp.sort() # Sort the list >>> tmp ['aa', 'bb', 'cc', 'dd'] >>> T = tuple(tmp) # Make a tuple from the list's items >>> T ('aa', 'bb', 'cc', 'dd') >>> sorted(T) # Or use the sorted built-in, and save two steps ['aa', 'bb', 'cc', 'dd'] 278 | Chapter 9: Tuples, Files, and Everything Else
- 331. Here, the list and tuple built-in functions are used to convert the object to a list and then back to a tuple; really, both calls make new objects, but the net effect is like a conversion. List comprehensions can also be used to convert tuples. The following, for example, makes a list from a tuple, adding 20 to each item along the way: >>> T = (1, 2, 3, 4, 5) >>> L = [x + 20 for x in T] >>> L [21, 22, 23, 24, 25] List comprehensions are really sequence operations—they always build new lists, but they may be used to iterate over any sequence objects, including tuples, strings, and other lists. As we’ll see later in the book, they even work on some things that are not physically stored sequences—any iterable objects will do, including files, which are automatically read line by line. Given this, they may be better called iteration tools. Although tuples don’t have the same methods as lists and strings, they do have two of their own as of Python 2.6 and 3.0—index and count work as they do for lists, but they are defined for tuple objects: >>> T = (1, 2, 3, 2, 4, 2) # Tuple methods in 2.6, 3.0, and later >>> T.index(2) # Offset of first appearance of 2 1 >>> T.index(2, 2) # Offset of appearance after offset 2 3 >>> T.count(2) # How many 2s are there? 3 Prior to 2.6 and 3.0, tuples have no methods at all—this was an old Python convention for immutable types, which was violated years ago on grounds of practicality with strings, and more recently with both numbers and tuples. Also, note that the rule about tuple immutability applies only to the top level of the tupleitself,nottoitscontents.Alistinsideatuple,forinstance,canbechangedasusual: >>> T = (1, [2, 3], 4) >>> T[1] = 'spam' # This fails: can't change tuple itself TypeError: object doesn't support item assignment >>> T[1][0] = 'spam' # This works: can change mutables inside >>> T (1, ['spam', 3], 4) For most programs, this one-level-deep immutability is sufficient for common tuple roles. Which, coincidentally, brings us to the next section. Why Lists and Tuples? This seems to be the first question that always comes up when teaching beginners about tuples: why do we need tuples if we have lists? Some of the reasoning may be historic; Tuples | 279
- 332. Python’s creator is a mathematician by training, and he has been quoted as seeing a tuple as a simple association of objects and a list as a data structure that changes over time. In fact, this use of the word “tuple” derives from mathematics, as does its frequent use for a row in a relational database table. The best answer, however, seems to be that the immutability of tuples provides some integrity—you can be sure a tuple won’t be changed through another reference else- where in a program, but there’s no such guarantee for lists. Tuples and other immut- ables, therefore, serve a similar role to “constant” declarations in other languages, though the notion of constantness is associated with objects in Python, not variables. Tuples can also be used in places that lists cannot—for example, as dictionary keys (see the sparse matrix example in Chapter 8). Some built-in operations may also require or imply tuples instead of lists (e.g., the substitution values in a string format expres- sion), though such operations have often been generalized in recent years to be more flexible. As a rule of thumb, lists are the tool of choice for ordered collections that might need to change; tuples can handle the other cases of fixed associations. Records Revisited: Named Tuples In fact, the choice of data types is even richer than the prior section may have implied —today’s Python programmers can choose from an assortment of both built-in core types, and extension types built on top of them. For example, in the prior chapter’s sidebar “Why You Will Care: Dictionaries Versus Lists” on page 263, we saw how to represent record-like information with both a list and a dictionary, and noted that dictionaries offer the advantage of more mnemonic keys that label data. As long as we don’t require mutability, tuples can serve similar roles, with positions for record fields like lists: >>> bob = ('Bob', 40.5, ['dev', 'mgr']) # Tuple record >>> bob ('Bob', 40.5, ['dev', 'mgr']) >>> bob[0], bob[2] # Access by position ('Bob', ['dev', 'mgr']) As for lists, though, field numbers in tuples generally carry less information than the names of keys in a dictionary. Here’s the same record recoded as a dictionary with named fields: >>> bob = dict(name='Bob', age=40.5, jobs=['dev', 'mgr']) # Dictionary record >>> bob {'jobs': ['dev', 'mgr'], 'name': 'Bob', 'age': 40.5} >>> bob['name'], bob['jobs'] # Access by key ('Bob', ['dev', 'mgr']) In fact, we can convert parts of the dictionary to a tuple if needed: 280 | Chapter 9: Tuples, Files, and Everything Else
- 333. >>> tuple(bob.values()) # Values to tuple (['dev', 'mgr'], 'Bob', 40.5) >>> list(bob.items()) # Items to tuple list [('jobs', ['dev', 'mgr']), ('name', 'Bob'), ('age', 40.5)] But with a bit of extra work, we can implement objects that offer both positional and named access to record fields. For example, the namedtuple utility, available in the standard library’s collections module mentioned in Chapter 8, implements an exten- sion type that adds logic to tuples that allows components to be accessed by both position and attribute name, and can be converted to dictionary-like form for access by key if desired. Attribute names come from classes and are not exactly dictionary keys, but they are similarly mnemonic: >>> from collections import namedtuple # Import extension type >>> Rec = namedtuple('Rec', ['name', 'age', 'jobs']) # Make a generated class >>> bob = Rec('Bob', age=40.5, jobs=['dev', 'mgr']) # A named-tuple record >>> bob Rec(name='Bob', age=40.5, jobs=['dev', 'mgr']) >>> bob[0], bob[2] # Access by position ('Bob', ['dev', 'mgr']) >>> bob.name, bob.jobs # Access by attribute ('Bob', ['dev', 'mgr']) Converting to a dictionary supports key-based behavior when needed: >>> O = bob._asdict() # Dictionary-like form >>> O['name'], O['jobs'] # Access by key too ('Bob', ['dev', 'mgr']) >>> O OrderedDict([('name', 'Bob'), ('age', 40.5), ('jobs', ['dev', 'mgr'])]) As you can see, named tuples are a tuple/class/dictionary hybrid. They also represent a classic tradeoff. In exchange for their extra utility, they require extra code (the two startup lines in the preceding examples that import the type and make the class), and incur some performance costs to work this magic. (In short, named tuples build new classes that extend the tuple type, inserting a property accessor method for each named field that maps the name to its position—a technique that relies on advanced topics we’ll explore in Part VIII, and uses formatted code strings instead of class annotation tools like decorators and metaclasses.) Still, they are a good example of the kind of custom data types that we can build on top of built-in types like tuples when extra utility is desired. Named tuples are available in Python 3.X, 2.7, 2.6 (where _asdict returns a true dic- tionary), and perhaps earlier, though they rely on features relatively modern by Python standards. They are also extensions, not core types—they live in the standard library and fall into the same category as Chapter 5’s Fraction and Decimal—so we’ll delegate to the Python library manual for more details. As a quick preview, though, both tuples and named tuples support unpacking tuple assignment, which we’ll study formally in Chapter 13, as well as the iteration contexts Tuples | 281
- 334. we’ll explore in Chapter 14 and Chapter 20 (notice the positional initial values here: named tuples accept these by name, position, or both): >>> bob = Rec('Bob', 40.5, ['dev', 'mgr']) # For both tuples and named tuples >>> name, age, jobs = bob # Tuple assignment (Chapter 11) >>> name, jobs ('Bob', ['dev', 'mgr']) >>> for x in bob: print(x) # Iteration context (Chapters 14, 20) ...prints Bob, 40.5, ['dev', 'mgr']... Tuple-unpacking assignment doesn’t quite apply to dictionaries, short of fetching and converting keys and values and assuming or imposing an positional ordering on them (dictionaries are not sequences), and iteration steps through keys, not values (notice the dictionary literal form here: an alternative to dict): >>> bob = {'name': 'Bob', 'age': 40.5, 'jobs': ['dev', 'mgr']} >>> job, name, age = bob.values() >>> name, job # Dict equivalent (but order may vary) ('Bob', ['dev', 'mgr']) >>> for x in bob: print(bob[x]) # Step though keys, index values ...prints values... >>> for x in bob.values(): print(x) # Step through values view ...prints values... Watch for a final rehash of this record representation thread when we see how user- defined classes compare in Chapter 27; as we’ll find, classes label fields with names too, but can also provide program logic to process the record’s data in the same package. Files You may already be familiar with the notion of files, which are named storage com- partmentsonyourcomputerthataremanagedbyyouroperatingsystem.Thelastmajor built-in object type that we’ll examine on our object types tour provides a way to access those files inside Python programs. In short, the built-in open function creates a Python file object, which serves as a link to a file residing on your machine. After calling open, you can transfer strings of data to and from the associated external file by calling the returned file object’s methods. Compared to the types you’ve seen so far, file objects are somewhat unusual. They are considered a core type because they are created by a built-in function, but they’re not numbers, sequences, or mappings, and they don’t respond to expression operators; they export only methods for common file-processing tasks. Most file methods are concerned with performing input from and output to the external file associated with a file object, but other file methods allow us to seek to a new position in the file, flush output buffers, and so on. Table 9-2 summarizes common file operations. 282 | Chapter 9: Tuples, Files, and Everything Else
- 335. Table 9-2. Common file operations Operation Interpretation output = open(r'C:spam', 'w') Create output file ('w' means write) input = open('data', 'r') Create input file ('r' means read) input = open('data') Same as prior line ('r' is the default) aString = input.read() Read entire file into a single string aString = input.read(N) Read up to next N characters (or bytes) into a string aString = input.readline() Read next line (including n newline) into a string aList = input.readlines() Read entire file into list of line strings (with n) output.write(aString) Write a string of characters (or bytes) into file output.writelines(aList) Write all line strings in a list into file output.close() Manual close (done for you when file is collected) output.flush() Flush output buffer to disk without closing anyFile.seek(N) Change file position to offset N for next operation for line in open('data'): use line File iterators read line by line open('f.txt', encoding='latin-1') Python 3.X Unicode text files (str strings) open('f.bin', 'rb') Python 3.X bytes files (bytes strings) codecs.open('f.txt', encoding='utf8') Python 2.X Unicode text files (unicode strings) open('f.bin', 'rb') Python 2.X bytes files (str strings) Opening Files To open a file, a program calls the built-in open function, with the external filename first, followed by a processing mode. The call returns a file object, which in turn has methods for data transfer: afile = open(filename, mode) afile.method() The first argument to open, the external filename, may include a platform-specific and absolute or relative directory path prefix. Without a directory path, the file is assumed to exist in the current working directory (i.e., where the script runs). As we’ll see in Chapter 37’s expanded file coverage, the filename may also contain non-ASCII Unicode characters that Python automatically translates to and from the underlying platform’s encoding, or be provided as a pre-encoded byte string. The second argument to open, processing mode, is typically the string 'r' to open for text input (the default), 'w' to create and open for text output, or 'a' to open for appending text to the end (e.g., for adding to logfiles). The processing mode argument can specify additional options: Files | 283
- 336. • Adding a b to the mode string allows for binary data (end-of-line translations and 3.X Unicode encodings are turned off). • Adding a + opens the file for both input and output (i.e., you can both read and write to the same file object, often in conjunction with seek operations to reposition in the file). Both of the first two arguments to open must be Python strings. An optional third ar- gument can be used to control output buffering—passing a zero means that output is unbuffered (it is transferred to the external file immediately on a write method call), and additional arguments may be provided for special types of files (e.g., an encoding for Unicode text files in Python 3.X). We’ll cover file fundamentals and explore some basic examples here, but we won’t go into all file-processing mode options; as usual, consult the Python library manual for additional details. Using Files Once you make a file object with open, you can call its methods to read from or write to the associated external file. In all cases, file text takes the form of strings in Python programs; reading a file returns its content in strings, and content is passed to the write methods as strings. Reading and writing methods come in multiple flavors; Table 9-2 lists the most common. Here are a few fundamental usage notes: File iterators are best for reading lines Though the reading and writing methods in the table are common, keep in mind that probably the best way to read lines from a text file today is to not read the file at all—as we’ll see in Chapter 14, files also have an iterator that automatically reads one line at a time in a for loop, list comprehension, or other iteration context. Content is strings, not objects Notice in Table 9-2 that data read from a file always comes back to your script as a string, so you’ll have to convert it to a different type of Python object if a string is not what you need. Similarly, unlike with the print operation, Python does not add any formatting and does not convert objects to strings automatically when you write data to a file—you must send an already formatted string. Because of this, the tools we have already met to convert objects to and from strings (e.g., int, float, str, and the string formatting expression and method) come in handy when dealing with files. Python also includes advanced standard library tools for handling generic object storage (the pickle module), for dealing with packed binary data in files (the struct module), and for processing special types of content such as JSON, XML, and CSV text. We’ll see these at work later in this chapter and book, but Python’s manuals document them in full. 284 | Chapter 9: Tuples, Files, and Everything Else
- 337. Files are buffered and seekable By default, output files are always buffered, which means that text you write may not be transferred from memory to disk immediately—closing a file, or running its flush method, forces the buffered data to disk. You can avoid buffering with extra open arguments, but it may impede performance. Python files are also random- access on a byte offset basis—their seek method allows your scripts to jump around to read and write at specific locations. close is often optional: auto-close on collection Calling the file close method terminates your connection to the external file, re- leases its system resources, and flushes its buffered output to disk if any is still in memory. As discussed in Chapter 6, in Python an object’s memory space is auto- matically reclaimed as soon as the object is no longer referenced anywhere in the program. When file objects are reclaimed, Python also automatically closes the files if they are still open (this also happens when a program shuts down). This means you don’t always need to manually close your files in standard Python, especially those in simple scripts with short runtimes, and temporary files used by a single line or expression. On the other hand, including manual close calls doesn’t hurt, and may be a good habit to form, especially in long-running systems. Strictly speaking, this auto-close- on-collection feature of files is not part of the language definition—it may change over time, may not happen when you expect it to in interactive shells, and may not work the same in other Python implementations whose garbage collectors may not reclaim and close files at the same points as standard CPython. In fact, when many files are opened within loops, Pythons other than CPython may require close calls to free up system resources immediately, before garbage collection can get around to freeing objects. Moreover, close calls may sometimes be required to flush buf- fered output of file objects not yet reclaimed. For an alternative way to guarantee automatic file closes, also see this section’s later discussion of the file object’s context manager, used with the with/as statement in Python 2.6, 2.7, and 3.X. Files in Action Let’s work through a simple example that demonstrates file-processing basics. The following code begins by opening a new text file for output, writing two lines (strings terminated with a newline marker, n), and closing the file. Later, the example opens the same file again in input mode and reads the lines back one at a time with read line. Notice that the third readline call returns an empty string; this is how Python file methods tell you that you’ve reached the end of the file (empty lines in the file come back as strings containing just a newline character, not as empty strings). Here’s the complete interaction: >>> myfile = open('myfile.txt', 'w') # Open for text output: create/empty >>> myfile.write('hello text filen') # Write a line of text: string 16 Files | 285
- 338. >>> myfile.write('goodbye text filen') 18 >>> myfile.close() # Flush output buffers to disk >>> myfile = open('myfile.txt') # Open for text input: 'r' is default >>> myfile.readline() # Read the lines back 'hello text filen' >>> myfile.readline() 'goodbye text filen' >>> myfile.readline() # Empty string: end-of-file '' Notice that file write calls return the number of characters written in Python 3.X; in 2.X they don’t, so you won’t see these numbers echoed interactively. This example writes each line of text, including its end-of-line terminator, n, as a string; write meth- ods don’t add the end-of-line character for us, so we must include it to properly ter- minate our lines (otherwise the next write will simply extend the current line in the file). If you want to display the file’s content with end-of-line characters interpreted, read the entire file into a string all at once with the file object’s read method and print it: >>> open('myfile.txt').read() # Read all at once into string 'hello text filengoodbye text filen' >>> print(open('myfile.txt').read()) # User-friendly display hello text file goodbye text file And if you want to scan a text file line by line, file iterators are often your best option: >>> for line in open('myfile.txt'): # Use file iterators, not reads ... print(line, end='') ... hello text file goodbye text file When coded this way, the temporary file object created by open will automatically read and return one line on each loop iteration. This form is usually easiest to code, good on memory use, and may be faster than some other options (depending on many vari- ables, of course). Since we haven’t reached statements or iterators yet, though, you’ll have to wait until Chapter 14 for a more complete explanation of this code. Windows users: As mentioned in Chapter 7, open accepts Unix-style for- ward slashes in place of backward slashes on Windows, so any of the following forms work for directory paths—raw strings, forward slashes, or doubled-up backslashes: >>> open(r'C:Python33Libpdb.py').readline() '#! /usr/bin/env python3n' >>> open('C:/Python33/Lib/pdb.py').readline() '#! /usr/bin/env python3n' 286 | Chapter 9: Tuples, Files, and Everything Else
- 339. >>> open('C:Python33Libpdb.py').readline() '#! /usr/bin/env python3n' The raw string form in the second command is still useful to turn off accidental escapes when you can’t control string content, and in other contexts. Text and Binary Files: The Short Story Strictly speaking, the example in the prior section uses text files. In both Python 3.X and 2.X, file type is determined by the second argument to open, the mode string—an included “b” means binary. Python has always supported both text and binary files, but in Python 3.X there is a sharper distinction between the two: • Text files represent content as normal str strings, perform Unicode encoding and decoding automatically, and perform end-of-line translation by default. • Binary files represent content as a special bytes string type and allow programs to access file content unaltered. In contrast, Python 2.X text files handle both 8-bit text and binary data, and a special string type and file interface (unicode strings and codecs.open) handles Unicode text. The differences in Python 3.X stem from the fact that simple and Unicode text have been merged in the normal string type—which makes sense, given that all text is Uni- code, including ASCII and other 8-bit encodings. Because most programmers deal only with ASCII text, they can get by with the basic text file interface used in the prior example, and normal strings. All strings are techni- cally Unicode in 3.X, but ASCII users will not generally notice. In fact, text files and strings work the same in 3.X and 2.X if your script’s scope is limited to such simple forms of text. If you need to handle internationalized applications or byte-oriented data, though, the distinction in 3.X impacts your code (usually for the better). In general, you must use bytes strings for binary files, and normal str strings for text files. Moreover, because text files implement Unicode encodings, you should not open a binary data file in text mode—decoding its content to Unicode text will likely fail. Let’s look at an example. When you read a binary data file you get back a bytes object —a sequence of small integers that represent absolute byte values (which may or may not correspond to characters), which looks and feels almost exactly like a normal string. In Python 3.X, and assuming an existing binary file: >>> data = open('data.bin', 'rb').read() # Open binary file: rb=read binary >>> data # bytes string holds binary data b'x00x00x00x07spamx00x08' >>> data[4:8] # Act like strings b'spam' >>> data[4:8][0] # But really are small 8-bit integers 115 Files | 287
- 340. >>> bin(data[4:8][0]) # Python 3.X/2.6+ bin() function '0b1110011' In addition, binary files do not perform any end-of-line translation on data; text files by default map all forms to and from n when written and read and implement Unicode encodings on transfers in 3.X. Binary files like this one work the same in Python 2.X, but byte strings are simply normal strings and have no leading b when displayed, and text files must use the codecs module to add Unicode processing. Per the note at the start of this chapter, though, that’s as much as we’re going to say about Unicode text and binary data files here, and just enough to understand upcoming examples in this chapter. Since the distinction is of marginal interest to many Python programmers, we’ll defer to the files preview in Chapter 4 for a quick tour and postpone the full story until Chapter 37. For now, let’s move on to some more substantial file examples to demonstrate a few common use cases. Storing Python Objects in Files: Conversions Our next example writes a variety of Python objects into a text file on multiple lines. Notice that it must convert objects to strings using conversion tools. Again, file data is always strings in our scripts, and write methods do not do any automatic to-string formatting for us (for space, I’m omitting byte-count return values from write methods from here on): >>> X, Y, Z = 43, 44, 45 # Native Python objects >>> S = 'Spam' # Must be strings to store in file >>> D = {'a': 1, 'b': 2} >>> L = [1, 2, 3] >>> >>> F = open('datafile.txt', 'w') # Create output text file >>> F.write(S + 'n') # Terminate lines with n >>> F.write('%s,%s,%sn' % (X, Y, Z)) # Convert numbers to strings >>> F.write(str(L) + '$' + str(D) + 'n') # Convert and separate with $ >>> F.close() Once we have created our file, we can inspect its contents by opening it and reading it into a string (strung together as a single operation here). Notice that the interactive echo gives the exact byte contents, while the print operation interprets embedded end- of-line characters to render a more user-friendly display: >>> chars = open('datafile.txt').read() # Raw string display >>> chars "Spamn43,44,45n[1, 2, 3]${'a': 1, 'b': 2}n" >>> print(chars) # User-friendly display Spam 43,44,45 [1, 2, 3]${'a': 1, 'b': 2} We now have to use other conversion tools to translate from the strings in the text file to real Python objects. As Python never converts strings to numbers (or other types of 288 | Chapter 9: Tuples, Files, and Everything Else
- 341. objects) automatically, this is required if we need to gain access to normal object tools like indexing, addition, and so on: >>> F = open('datafile.txt') # Open again >>> line = F.readline() # Read one line >>> line 'Spamn' >>> line.rstrip() # Remove end-of-line 'Spam' For this first line, we used the string rstrip method to get rid of the trailing end-of-line character; a line[:−1] slice would work, too, but only if we can be sure all lines end in the n character (the last line in a file sometimes does not). So far, we’ve read the line containing the string. Now let’s grab the next line, which contains numbers, and parse out (that is, extract) the objects on that line: >>> line = F.readline() # Next line from file >>> line # It's a string here '43,44,45n' >>> parts = line.split(',') # Split (parse) on commas >>> parts ['43', '44', '45n'] We used the string split method here to chop up the line on its comma delimiters; the result is a list of substrings containing the individual numbers. We still must convert from strings to integers, though, if we wish to perform math on these: >>> int(parts[1]) # Convert from string to int 44 >>> numbers = [int(P) for P in parts] # Convert all in list at once >>> numbers [43, 44, 45] As we have learned, int translates a string of digits into an integer object, and the list comprehension expression introduced in Chapter 4 can apply the call to each item in our list all at once (you’ll find more on list comprehensions later in this book). Notice that we didn’t have to run rstrip to delete the n at the end of the last part; int and some other converters quietly ignore whitespace around digits. Finally, to convert the stored list and dictionary in the third line of the file, we can run them through eval, a built-in function that treats a string as a piece of executable pro- gram code (technically, a string containing a Python expression): >>> line = F.readline() >>> line "[1, 2, 3]${'a': 1, 'b': 2}n" >>> parts = line.split('$') # Split (parse) on $ >>> parts ['[1, 2, 3]', "{'a': 1, 'b': 2}n"] >>> eval(parts[0]) # Convert to any object type [1, 2, 3] >>> objects = [eval(P) for P in parts] # Do same for all in list Files | 289
- 342. >>> objects [[1, 2, 3], {'a': 1, 'b': 2}] Because the end result of all this parsing and converting is a list of normal Python objects instead of strings, we can now apply list and dictionary operations to them in our script. Storing Native Python Objects: pickle Using eval to convert from strings to objects, as demonstrated in the preceding code, is a powerful tool. In fact, sometimes it’s too powerful. eval will happily run any Python expression—even one that might delete all the files on your computer, given the nec- essary permissions! If you really want to store native Python objects, but you can’t trust the source of the data in the file, Python’s standard library pickle module is ideal. The pickle module is a more advanced tool that allows us to store almost any Python object in a file directly, with no to- or from-string conversion requirement on our part. It’s like a super-general data formatting and parsing utility. To store a dictionary in a file, for instance, we pickle it directly: >>> D = {'a': 1, 'b': 2} >>> F = open('datafile.pkl', 'wb') >>> import pickle >>> pickle.dump(D, F) # Pickle any object to file >>> F.close() Then, to get the dictionary back later, we simply use pickle again to re-create it: >>> F = open('datafile.pkl', 'rb') >>> E = pickle.load(F) # Load any object from file >>> E {'a': 1, 'b': 2} We get back an equivalent dictionary object, with no manual splitting or converting required. The pickle module performs what is known as object serialization—convert- ing objects to and from strings of bytes—but requires very little work on our part. In fact, pickle internally translates our dictionary to a string form, though it’s not much to look at (and may vary if we pickle in other data protocol modes): >>> open('datafile.pkl', 'rb').read() # Format is prone to change! b'x80x03}qx00(Xx01x00x00x00bqx01Kx02Xx01x00x00x00aqx02Kx01u.' Because pickle can reconstruct the object from this format, we don’t have to deal with it ourselves. For more on the pickle module, see the Python standard library manual, or import pickle and pass it to help interactively. While you’re exploring, also take a look at the shelve module. shelve is a tool that uses pickle to store Python objects in an access-by-key filesystem, which is beyond our scope here (though you will get to see an example of shelve in action in Chapter 28, and other pickle examples in Chap- ter 31 and Chapter 37). 290 | Chapter 9: Tuples, Files, and Everything Else
- 343. Notice that I opened the file used to store the pickled object in binary mode; binary mode is always required in Python 3.X, because the pickler creates and uses a bytes string object, and these objects imply binary- mode files (text-mode files imply str strings in 3.X). In earlier Pythons it’s OK to use text-mode files for protocol 0 (the default, which creates ASCII text), as long as text mode is used consistently; higher protocols require binary-mode files. Python 3.X’s default protocol is 3 (binary), but it creates bytes even for protocol 0. See Chapter 28, Chapter 31, and Chapter37;Python’slibrarymanual;orreferencebooksformoredetails on and examples of pickled data. Python 2.X also has a cPickle module, which is an optimized version of pickle that can be imported directly for speed. Python 3.X renames this module _pickle and uses it automatically in pickle—scripts simply im- port pickle and let Python optimize itself. Storing Python Objects in JSON Format The prior section’s pickle module translates nearly arbitrary Python objects to a pro- prietary format developed specifically for Python, and honed for performance over many years. JSON is a newer and emerging data interchange format, which is both programming-language-neutral and supported by a variety of systems. MongoDB, for instance, stores data in a JSON document database (using a binary JSON format). JSON does not support as broad a range of Python object types as pickle, but its portability is an advantage in some contexts, and it represents another way to serialize a specific category of Python objects for storage and transmission. Moreover, because JSON is so close to Python dictionaries and lists in syntax, the translation to and from Python objects is trivial, and is automated by the json standard library module. For example, a Python dictionary with nested structures is very similar to JSON data, though Python’s variables and expressions support richer structuring options (any part of the following can be an arbitrary expression in Python code): >>> name = dict(first='Bob', last='Smith') >>> rec = dict(name=name, job=['dev', 'mgr'], age=40.5) >>> rec {'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5} The final dictionary format displayed here is a valid literal in Python code, and almost passes for JSON when printed as is, but the json module makes the translation official —here translating Python objects to and from a JSON serialized string representation in memory: >>> import json >>> json.dumps(rec) '{"job": ["dev", "mgr"], "name": {"last": "Smith", "first": "Bob"}, "age": 40.5}' >>> S = json.dumps(rec) >>> S Files | 291
- 344. '{"job": ["dev", "mgr"], "name": {"last": "Smith", "first": "Bob"}, "age": 40.5}' >>> O = json.loads(S) >>> O {'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5} >>> O == rec True It’s similarly straightforward to translate Python objects to and from JSON data strings in files. Prior to being stored in a file, your data is simply Python objects; the JSON module recreates them from the JSON textual representation when it loads it from the file: >>> json.dump(rec, fp=open('testjson.txt', 'w'), indent=4) >>> print(open('testjson.txt').read()) { "job": [ "dev", "mgr" ], "name": { "last": "Smith", "first": "Bob" }, "age": 40.5 } >>> P = json.load(open('testjson.txt')) >>> P {'job': ['dev', 'mgr'], 'name': {'last': 'Smith', 'first': 'Bob'}, 'age': 40.5} Once you’ve translated from JSON text, you process the data using normal Python object operations in your script. For more details on JSON-related topics, see Python’s library manuals and search the Web. Note that strings are all Unicode in JSON to support text drawn from international character sets, so you’ll see a leading u on strings after translating from JSON data in Python 2.X (but not in 3.X); this is just the syntax of Unicode objects in 2.X, as intro- duced Chapter 4 and Chapter 7, and covered in full in Chapter 37. Because Unicode text strings support all the usual string operations, the difference is negligible to your code while text resides in memory; the distinction matters most when transferring text to and from files, and then usually only for non-ASCII types of text where encodings come into play. There is also support in the Python world for translating objects to and from XML, a text format used in Chapter 37; see the web for details.For another semirelated tool that deals with formatted data files, see the standard library’s csv module. It parses and creates CSV (comma-sep- arated value) data in files and strings. This doesn’t map as directly to Python objects, but is another common data exchange format: >>> import csv >>> rdr = csv.reader(open('csvdata.txt')) 292 | Chapter 9: Tuples, Files, and Everything Else
- 345. >>> for row in rdr: print(row) ... ['a', 'bbb', 'cc', 'dddd'] ['11', '22', '33', '44'] Storing Packed Binary Data: struct One other file-related note before we move on: some advanced applications also need to deal with packed binary data, created perhaps by a C language program or a network connection. Python’s standard library includes a tool to help in this domain—the struct module knows how to both compose and parse packed binary data. In a sense, this is another data-conversion tool that interprets strings in files as binary data. We saw an overview of this tool in Chapter 4, but let’s take another quick look here for more perspective. To create a packed binary data file, open it in 'wb' (write binary) mode, and pass struct a format string and some Python objects. The format string used here means pack as a 4-byte integer, a 4-character string (which must be a bytes string as of Python 3.2), and a 2-byte integer, all in big-endian form (other format codes handle padding bytes, floating-point numbers, and more): >>> F = open('data.bin', 'wb') # Open binary output file >>> import struct >>> data = struct.pack('>i4sh', 7, b'spam', 8) # Make packed binary data >>> data b'x00x00x00x07spamx00x08' >>> F.write(data) # Write byte string >>> F.close() Python creates a binary bytes data string, which we write out to the file normally—this one consists mostly of nonprintable characters printed in hexadecimal escapes, and is the same binary file we met earlier. To parse the values out to normal Python objects, we simply read the string back and unpack it using the same format string. Python extracts the values into normal Python objects—integers and a string: >>> F = open('data.bin', 'rb') >>> data = F.read() # Get packed binary data >>> data b'x00x00x00x07spamx00x08' >>> values = struct.unpack('>i4sh', data) # Convert to Python objects >>> values (7, b'spam', 8) Binary data files are advanced and somewhat low-level tools that we won’t cover in more detail here; for more help, see the struct coverage in Chapter 37, consult the Python library manual, or import struct and pass it to the help function interactively. Also note that you can use the binary file-processing modes 'wb' and 'rb' to process a simpler binary file, such as an image or audio file, as a whole without having to unpack its contents; in such cases your code might pass it unparsed to other files or tools. Files | 293
- 346. File Context Managers You’ll also want to watch for Chapter 34’s discussion of the file’s context manager support, new as of Python 3.0 and 2.6. Though more a feature of exception processing than files themselves, it allows us to wrap file-processing code in a logic layer that ensures that the file will be closed (and if needed, have its output flushed to disk) automatically on exit, instead of relying on the auto-close during garbage collection: with open(r'C:codedata.txt') as myfile: # See Chapter 34 for details for line in myfile: ...use line here... The try/finally statement that we’ll also study in Chapter 34 can provide similar functionality, but at some cost in extra code—three extra lines, to be precise (though we can often avoid both options and let Python close files for us automatically): myfile = open(r'C:codedata.txt') try: for line in myfile: ...use line here... finally: myfile.close() The with context manager scheme ensures release of system resources in all Pythons, and may be more useful for output files to guarantee buffer flushes; unlike the more general try, though, it is also limited to objects that support its protocol. Since both these options require more information than we have yet obtained, however, we’ll postpone details until later in this book. Other File Tools There are additional, more specialized file methods shown in Table 9-2, and even more that are not in the table. For instance, as mentioned earlier, seek resets your current position in a file (the next read or write happens at that position), flush forces buffered output to be written out to disk without closing the connection (by default, files are always buffered), and so on. The Python standard library manual and the reference books described in the preface provide complete lists of file methods; for a quick look, run a dir or help call interac- tively, passing in an open file object (in Python 2.X but not 3.X, you can pass in the name file instead). For more file-processing examples, watch for the sidebar “Why You Will Care: File Scanners” on page 400 in Chapter 13. It sketches common file- scanning loop code patterns with statements we have not covered enough yet to use here. Also, note that although the open function and the file objects it returns are your main interface to external files in a Python script, there are additional file-like tools in the Python toolset. Among these: 294 | Chapter 9: Tuples, Files, and Everything Else
- 347. Standard streams Preopened file objects in the sys module, such as sys.stdout (see “Print Opera- tions” on page 358 in Chapter 11 for details) Descriptor files in the os module Integer file handles that support lower-level tools such as file locking (see also the “x” mode in Python 3.3’s open for exclusive creation) Sockets, pipes, and FIFOs File-like objects used to synchronize processes or communicate over networks Access-by-key files known as “shelves” Used to store unaltered and pickled Python objects directly, by key (used in Chap- ter 28) Shell command streams Tools such as os.popen and subprocess.Popen that support spawning shell com- mands and reading and writing to their standard streams (see Chapter 13 and Chapter 21 for examples) The third-party open source domain offers even more file-like tools, including support for communicating with serial ports in the PySerial extension and interactive programs in the pexpect system. See applications-focused Python texts and the Web at large for additional information on file-like tools. Version skew note: In Python 2.X, the built-in name open is essentially a synonym for the name file, and you may technically open files by call- ing either open or file (though open is generally preferred for opening). In Python 3.X, the name file is no longer available, because of its re- dundancy with open. Python 2.X users may also use the name file as the file object type, in order to customize files with object-oriented programming (described later in this book). In Python 3.X, files have changed radically. The classes used to implement file objects live in the standard library module io. See this module’s documentation or code for the classes it makes available for customization, and run a type(F) call on an open file F for hints. Core Types Review and Summary Now that we’ve seen all of Python’s core built-in types in action, let’s wrap up our object types tour by reviewing some of the properties they share. Table 9-3 classifies all the major types we’ve seen so far according to the type categories introduced earlier. Here are some points to remember: Core Types Review and Summary | 295
- 348. • Objects share operations according to their category; for instance, sequence objects —strings, lists, and tuples—all share sequence operations such as concatenation, length, and indexing. • Only mutable objects—lists, dictionaries, and sets—may be changed in place; you cannot change numbers, strings, or tuples in place. • Files export only methods, so mutability doesn’t really apply to them—their state may be changed when they are processed, but this isn’t quite the same as Python core type mutability constraints. • “Numbers” in Table 9-3 includes all number types: integer (and the distinct long integer in 2.X), floating point, complex, decimal, and fraction. • “Strings” in Table 9-3 includes str, as well as bytes in 3.X and unicode in 2.X; the bytearray string type in 3.X, 2.6, and 2.7 is mutable. • Sets are something like the keys of a valueless dictionary, but they don’t map to values and are not ordered, so sets are neither a mapping nor a sequence type; frozenset is an immutable variant of set. • In addition to type category operations, as of Python 2.6 and 3.0 all the types in Table 9-3 have callable methods, which are generally specific to their type. Table 9-3. Object classifications Object type Category Mutable? Numbers (all) Numeric No Strings (all) Sequence No Lists Sequence Yes Dictionaries Mapping Yes Tuples Sequence No Files Extension N/A Sets Set Yes Frozenset Set No bytearray Sequence Yes Why You Will Care: Operator Overloading In Part VI of this book, we’ll see that objects we implement with classes can pick and choose from these categories arbitrarily. For instance, if we want to provide a new kind of specialized sequence object that is consistent with built-in sequences, we can code a class that overloads things like indexing and concatenation: class MySequence: def __getitem__(self, index): # Called on self[index], others def __add__(self, other): # Called on self + other 296 | Chapter 9: Tuples, Files, and Everything Else
- 349. def __iter__(self): # Preferred in iterations and so on. We can also make the new object mutable or not by selectively implementing methods called for in-place change operations (e.g., __setitem__ is called on self[index]=value assignments). Although it’s beyond this book’s scope, it’s also pos- sible to implement new objects in an external language like C as C extension types. For these, we fill in C function pointer slots to choose between number, sequence, and mapping operation sets. Object Flexibility This part of the book introduced a number of compound object types—collections with components. In general: • Lists, dictionaries, and tuples can hold any kind of object. • Sets can contain any type of immutable object. • Lists, dictionaries, and tuples can be arbitrarily nested. • Lists, dictionaries, and sets can dynamically grow and shrink. Because they support arbitrary structures, Python’s compound object types are good at representing complex information in programs. For example, values in dictionaries may be lists, which may contain tuples, which may contain dictionaries, and so on. The nesting can be as deep as needed to model the data to be processed. Let’s look at an example of nesting. The following interaction defines a tree of nested compound sequence objects, shown in Figure 9-1. To access its components, you may include as many index operations as required. Python evaluates the indexes from left to right, and fetches a reference to a more deeply nested object at each step. Fig- ure 9-1 may be a pathologically complicated data structure, but it illustrates the syntax used to access nested objects in general: >>> L = ['abc', [(1, 2), ([3], 4)], 5] >>> L[1] [(1, 2), ([3], 4)] >>> L[1][1] ([3], 4) >>> L[1][1][0] [3] >>> L[1][1][0][0] 3 References Versus Copies Chapter 6 mentioned that assignments always store references to objects, not copies of those objects. In practice, this is usually what you want. Because assignments can generate multiple references to the same object, though, it’s important to be aware that Core Types Review and Summary | 297
- 350. changing a mutable object in place may affect other references to the same object else- where in your program. If you don’t want such behavior, you’ll need to tell Python to copy the object explicitly. We studied this phenomenon in Chapter 6, but it can become more subtle when larger objects of the sort we’ve explored since then come into play. For instance, the following example creates a list assigned to X, and another list assigned to L that embeds a refer- ence back to list X. It also creates a dictionary D that contains another reference back to list X: >>> X = [1, 2, 3] >>> L = ['a', X, 'b'] # Embed references to X's object >>> D = {'x':X, 'y':2} At this point, there are three references to the first list created: from the name X, from inside the list assigned to L, and from inside the dictionary assigned to D. The situation is illustrated in Figure 9-2. Because lists are mutable, changing the shared list object from any of the three refer- ences also changes what the other two reference: >>> X[1] = 'surprise' # Changes all three references! >>> L ['a', [1, 'surprise', 3], 'b'] >>> D {'x': [1, 'surprise', 3], 'y': 2} References are a higher-level analog of pointers in other languages that are always fol- lowed when used. Although you can’t grab hold of the reference itself, it’s possible to Figure 9-1. A nested object tree with the offsets of its components, created by running the literal expression [‘abc’, [(1, 2), ([3], 4)], 5]. Syntactically nested objects are internally represented as references (i.e., pointers) to separate pieces of memory. 298 | Chapter 9: Tuples, Files, and Everything Else
- 351. store the same reference in more than one place (variables, lists, and so on). This is a feature—you can pass a large object around a program without generating expensive copies of it along the way. If you really do want copies, however, you can request them: • Slice expressions with empty limits (L[:]) copy sequences. • The dictionary, set, and list copy method (X.copy()) copies a dictionary, set, or list (the list’s copy is new as of 3.3). • Some built-in functions, such as list and dict make copies (list(L), dict(D), set(S)). • The copy standard library module makes full copies when needed. For example, say you have a list and a dictionary, and you don’t want their values to be changed through other variables: >>> L = [1,2,3] >>> D = {'a':1, 'b':2} To prevent this, simply assign copies to the other variables, not references to the same objects: >>> A = L[:] # Instead of A = L (or list(L)) >>> B = D.copy() # Instead of B = D (ditto for sets) This way, changes made from the other variables will change the copies, not the orig- inals: >>> A[1] = 'Ni' >>> B['c'] = 'spam' >>> >>> L, D ([1, 2, 3], {'a': 1, 'b': 2}) Figure 9-2. Shared object references: because the list referenced by variable X is also referenced from within the objects referenced by L and D, changing the shared list from X makes it look different from L and D, too. Core Types Review and Summary | 299
- 352. >>> A, B ([1, 'Ni', 3], {'a': 1, 'c': 'spam', 'b': 2}) In terms of our original example, you can avoid the reference side effects by slicing the original list instead of simply naming it: >>> X = [1, 2, 3] >>> L = ['a', X[:], 'b'] # Embed copies of X's object >>> D = {'x':X[:], 'y':2} This changes the picture in Figure 9-2—L and D will now point to different lists than X. The net effect is that changes made throughX will impact only X, not L and D; similarly, changes to L or D will not impact X. One final note on copies: empty-limit slices and the dictionary copy method only make top-level copies; that is, they do not copy nested data structures, if any are present. If you need a complete, fully independent copy of a deeply nested data structure (like the various record structures we’ve coded in recent chapters), use the standard copy mod- ule, introduced in Chapter 6: import copy X = copy.deepcopy(Y) # Fully copy an arbitrarily nested object Y This call recursively traverses objects to copy all their parts. This is a much more rare case, though, which is why you have to say more to use this scheme. References are usually what you will want; when they are not, slices and copy methods are usually as much copying as you’ll need to do. Comparisons, Equality, and Truth All Python objects also respond to comparisons: tests for equality, relative magnitude, and so on. Python comparisons always inspect all parts of compound objects until a resultcanbedetermined.Infact,whennestedobjectsarepresent,Pythonautomatically traverses data structures to apply comparisons from left to right, and as deeply as needed. The first difference found along the way determines the comparison result. This is sometimes called a recursive comparison—the same comparison requested on the top-level objects is applied to each of the nested objects, and to each of their nested objects, and so on, until a result is found. Later in this book—in Chapter 19—we’ll see how to write recursive functions of our own that work similarly on nested structures. For now, think about comparing all the linked pages at two websites if you want a metaphor for such structures, and a reason for writing recursive functions to process them. In terms of core types, the recursion is automatic. For instance, a comparison of list objects compares all their components automatically until a mismatch is found or the end is reached: >>> L1 = [1, ('a', 3)] # Same value, unique objects >>> L2 = [1, ('a', 3)] 300 | Chapter 9: Tuples, Files, and Everything Else
- 353. >>> L1 == L2, L1 is L2 # Equivalent? Same object? (True, False) Here, L1 and L2 are assigned lists that are equivalent but distinct objects. As a review of what we saw in Chapter 6, because of the nature of Python references, there are two ways to test for equality: • The == operator tests value equivalence. Python performs an equivalence test, comparing all nested objects recursively. • The is operator tests object identity. Python tests whether the two are really the same object (i.e., live at the same address in memory). In the preceding example, L1 and L2 pass the == test (they have equivalent values because all their components are equivalent) but fail the is check (they reference two different objects, and hence two different pieces of memory). Notice what happens for short strings, though: >>> S1 = 'spam' >>> S2 = 'spam' >>> S1 == S2, S1 is S2 (True, True) Here, we should again have two distinct objects that happen to have the same value: == should be true, and is should be false. But because Python internally caches and reuses some strings as an optimization, there really is just a single string 'spam' in memory, shared by S1 and S2; hence, the is identity test reports a true result. To trigger the normal behavior, we need to use longer strings: >>> S1 = 'a longer string' >>> S2 = 'a longer string' >>> S1 == S2, S1 is S2 (True, False) Of course, because strings are immutable, the object caching mechanism is irrelevant to your code—strings can’t be changed in place, regardless of how many variables refer to them. If identity tests seem confusing, see Chapter 6 for a refresher on object refer- ence concepts. As a rule of thumb, the == operator is what you will want to use for almost all equality checks; is is reserved for highly specialized roles. We’ll see cases later in the book where both operators are put to use. Relative magnitude comparisons are also applied recursively to nested data structures: >>> L1 = [1, ('a', 3)] >>> L2 = [1, ('a', 2)] >>> L1 < L2, L1 == L2, L1 > L2 # Less, equal, greater: tuple of results (False, False, True) Here, L1 is greater than L2 because the nested 3 is greater than 2. By now you should know that the result of the last line is really a tuple of three objects—the results of the three expressions typed (an example of a tuple without its enclosing parentheses). Core Types Review and Summary | 301
- 354. More specifically, Python compares types as follows: • Numbers are compared by relative magnitude, after conversion to the common highest type if needed. • Strings are compared lexicographically (by the character set code point values re- turned by ord), and character by character until the end or first mismatch ("abc" < "ac"). • Lists and tuples are compared by comparing each component from left to right, and recursively for nested structures, until the end or first mismatch ([2] > [1, 2]). • Sets are equal if both contain the same items (formally, if each is a subset of the other), and set relative magnitude comparisons apply subset and superset tests. • Dictionaries compare as equal if their sorted (key, value) lists are equal. Relative magnitude comparisons are not supported for dictionaries in Python 3.X, but they work in 2.X as though comparing sorted (key, value) lists. • Nonnumeric mixed-type magnitude comparisons (e.g., 1 < 'spam') are errors in Python 3.X. They are allowed in Python 2.X, but use a fixed but arbitrary ordering rule based on type name string. By proxy, this also applies to sorts, which use comparisons internally: nonnumeric mixed-type collections cannot be sorted in 3.X. In general, comparisons of structured objects proceed as though you had written the objects as literals and compared all their parts one at a time from left to right. In later chapters, we’ll see other object types that can change the way they get compared. Python 2.X and 3.X mixed-type comparisons and sorts Per the last point in the preceding section’s list, the change in Python 3.X for nonnu- meric mixed-type comparisons applies to magnitude tests, not equality, but it also ap- plies by proxy to sorting, which does magnitude testing internally. In Python 2.X these all work, though mixed types compare by an arbitrary ordering: c:code> c:python27python >>> 11 == '11' # Equality does not convert non-numbers False >>> 11 >= '11' # 2.X compares by type name string: int, str False >>> ['11', '22'].sort() # Ditto for sorts >>> [11, '11'].sort() But Python 3.X disallows mixed-type magnitude testing, except numeric types and manually converted types: c:code> c:python33python >>> 11 == '11' # 3.X: equality works but magnitude does not False >>> 11 >= '11' TypeError: unorderable types: int() > str() 302 | Chapter 9: Tuples, Files, and Everything Else
- 355. >>> ['11', '22'].sort() # Ditto for sorts >>> [11, '11'].sort() TypeError: unorderable types: str() < int() >>> 11 > 9.123 # Mixed numbers convert to highest type True >>> str(11) >= '11', 11 >= int('11') # Manual conversions force the issue (True, True) Python 2.X and 3.X dictionary comparisons The second-to-last point in the preceding section also merits illustration. In Python 2.X, dictionaries support magnitude comparisons, as though you were comparing sor- ted key/value lists: C:code> c:python27python >>> D1 = {'a':1, 'b':2} >>> D2 = {'a':1, 'b':3} >>> D1 == D2 # Dictionary equality: 2.X + 3.X False >>> D1 < D2 # Dictionary magnitude: 2.X only True As noted briefly in Chapter 8, though, magnitude comparisons for dictionaries are removed in Python 3.X because they incur too much overhead when equality is desired (equality uses an optimized scheme in 3.X that doesn’t literally compare sorted key/ value lists): C:code> c:python33python >>> D1 = {'a':1, 'b':2} >>> D2 = {'a':1, 'b':3} >>> D1 == D2 False >>> D1 < D2 TypeError: unorderable types: dict() < dict() The alternative in 3.X is to either write loops to compare values by key, or compare the sorted key/value lists manually—the items dictionary methods and sorted built-in suf- fice: >>> list(D1.items()) [('b', 2), ('a', 1)] >>> sorted(D1.items()) [('a', 1), ('b', 2)] >>> >>> sorted(D1.items()) < sorted(D2.items()) # Magnitude test in 3.X True >>> sorted(D1.items()) > sorted(D2.items()) False This takes more code, but in practice, most programs requiring this behavior will de- velop more efficient ways to compare data in dictionaries than either this workaround or the original behavior in Python 2.X. Core Types Review and Summary | 303
- 356. The Meaning of True and False in Python Notice that the test results returned in the last two examples represent true and false values. They print as the words True and False, but now that we’re using logical tests like these in earnest, I should be a bit more formal about what these names really mean. In Python, as in most programming languages, an integer 0 represents false, and an integer 1 represents true. In addition, though, Python recognizes any empty data struc- ture as false and any nonempty data structure as true. More generally, the notions of true and false are intrinsic properties of every object in Python—each object is either true or false, as follows: • Numbers are false if zero, and true otherwise. • Other objects are false if empty, and true otherwise. Table 9-4 gives examples of true and false values of objects in Python. Table 9-4. Example object truth values Object Value "spam" True "" False [1, 2] True [] False {'a': 1} True {} False 1 True 0.0 False None False As one application, because objects are true or false themselves, it’s common to see Python programmers code tests like if X:, which, assuming X is a string, is the same as if X != '':. In other words, you can test the object itself to see if it contains anything, instead of comparing it to an empty, and therefore false, object of the same type (more on if statements in the next chapter). The None object As shown in the last row in Table 9-4, Python also provides a special object called None, which is always considered to be false. None was introduced briefly in Chap- ter 4; it is the only value of a special data type in Python and typically serves as an empty placeholder (much like a NULL pointer in C). For example, recall that for lists you cannot assign to an offset unless that offset already exists—the list does not magically grow if you attempt an out-of-bounds assignment. 304 | Chapter 9: Tuples, Files, and Everything Else
- 357. To preallocate a 100-item list such that you can add to any of the 100 offsets, you can fill it with None objects: >>> L = [None] * 100 >>> >>> L [None, None, None, None, None, None, None, ... ] This doesn’t limit the size of the list (it can still grow and shrink later), but simply presets an initial size to allow for future index assignments. You could initialize a list with zeros the same way, of course, but best practice dictates using None if the type of the list’s contents is variable or not yet known. Keep in mind that None does not mean “undefined.” That is, None is something, not nothing (despite its name!)—it is a real object and a real piece of memory that is created and given a built-in name by Python itself. Watch for other uses of this special object later in the book; as we’ll learn in Part IV, it is also the default return value of functions that don’t exit by running into a return statement with a result value. The bool type While we’re on the topic of truth, also keep in mind that the Python Boolean type bool, introduced in Chapter 5, simply augments the notions of true and false in Python. As we learned in Chapter 5, the built-in words True and False are just customized versions of the integers 1 and 0—it’s as if these two words have been preassigned to 1 and 0 everywhere in Python. Because of the way this new type is implemented, this is really just a minor extension to the notions of true and false already described, designed to make truth values more explicit: • When used explicitly in truth test code, the words True and False are equivalent to 1 and 0, but they make the programmer’s intent clearer. • Results of Boolean tests run interactively print as the words True and False, instead of as 1 and 0, to make the type of result clearer. You are not required to use only Boolean types in logical statements such as if; all objects are still inherently true or false, and all the Boolean concepts mentioned in this chapter still work as described if you use other types. Python also provides a bool built- in function that can be used to test the Boolean value of an object if you want to make this explicit (i.e., whether it is true—that is, nonzero or nonempty): >>> bool(1) True >>> bool('spam') True >>> bool({}) False In practice, though, you’ll rarely notice the Boolean type produced by logic tests, be- cause Boolean results are used automatically by if statements and other selection tools. We’ll explore Booleans further when we study logical statements in Chapter 12. Core Types Review and Summary | 305
- 358. Python’s Type Hierarchies As a summary and reference, Figure 9-3 sketches all the built-in object types available in Python and their relationships. We’ve looked at the most prominent of these; most of the other kinds of objects in Figure 9-3 correspond to program units (e.g., functions and modules) or exposed interpreter internals (e.g., stack frames and compiled code). The largest point to notice here is that everything in a Python system is an object type and may be processed by your Python programs. For instance, you can pass a class to a function, assign it to a variable, stuff it in a list or dictionary, and so on. Type Objects In fact, even types themselves are an object type in Python: the type of an object is an object of type type (say that three times fast!). Seriously, a call to the built-in function type(X) returns the type object of object X. The practical application of this is that type objects can be used for manual type comparisons in Python if statements. However, for reasons introduced in Chapter 4, manual type testing is usually not the right thing to do in Python, since it limits your code’s flexibility. One note on type names: as of Python 2.2, each core type has a new built-in name added to support type customization through object-oriented subclassing: dict, list, str, tuple, int, float, complex, bytes, type, set, and more. In Python 3.X names all references classes, and in Python 2.X but not 3.X, file is also a type name and a syn- onym for open. Calls to these names are really object constructor calls, not simply con- version functions, though you can treat them as simple functions for basic usage. In addition, the types standard library module in Python 3.X provides additional type names for types that are not available as built-ins (e.g., the type of a function; in Python 2.X but not 3.X, this module also includes synonyms for built-in type names), and it is possible to do type tests with the isinstance function. For example, all of the following type tests are true: type([1]) == type([]) # Compare to type of another list type([1]) == list # Compare to list type name isinstance([1], list) # Test if list or customization thereof import types # types has names for other types def f(): pass type(f) == types.FunctionType Because types can be subclassed in Python today, the isinstance technique is generally recommended. See Chapter 32 for more on subclassing built-in types in Python 2.2 and later. 306 | Chapter 9: Tuples, Files, and Everything Else
- 359. Figure 9-3. Python’s major built-in object types, organized by categories. Everything is a type of object in Python, even the type of an object! Some extension types, such as named tuples, might belong in this figure too, but the criteria for inclusion in the core types set are not formal. Core Types Review and Summary | 307
- 360. Also in Chapter 32, we will explore how type(X) and type testing in general apply to instances of user-defined classes. In short, in Python 3.X and for new-style classes in Python 2.X, the type of a class instance is the class from which the instance was made. For classic classes in Python 2.X, all class instances are instead of the type “instance,” and we must compare instance __class__ attributes to compare their types meaningfully. Since we’re not yet equipped to tackle the subject of classes, we’ll postpone the rest of this story until Chapter 32. Other Types in Python Besides the core objects studied in this part of the book, and the program-unit objects such as functions, modules, and classes that we’ll meet later, a typical Python instal- lation has dozens of additional object types available as linked-in C extensions or Python classes—regular expression objects, DBM files, GUI widgets, network sockets, and so on. Depending on whom you ask, the named tuple we met earlier in this chapter may fall in this category too (Decimal and Fraction of Chapter 5 tend to be more am- biguous). The main difference between these extra tools and the built-in types we’ve seen so far is that the built-ins provide special language creation syntax for their objects (e.g., 4 for an integer, [1,2] for a list, the open function for files, and def and lambda for functions). Other tools are generally made available in standard library modules that you must first import to use, and aren’t usually considered core types. For instance, to make a regular expression object, you import re and call re.compile(). See Python’s library reference for a comprehensive guide to all the tools available to Python programs. Built-in Type Gotchas That’s the end of our look at core data types. We’ll wrap up this part of the book with a discussion of common problems that seem to trap new users (and the occasional expert), along with their solutions. Some of this is a review of ideas we’ve already cov- ered, but these issues are important enough to warn about again here. Assignment Creates References, Not Copies Because this is such a central concept, I’ll mention it again: shared references to mutable objects in your program can matter. For instance, in the following example, the list object assigned to the name L is referenced both from L and from inside the list assigned to the name M. Changing L in place changes what M references, too: >>> L = [1, 2, 3] >>> M = ['X', L, 'Y'] # Embed a reference to L >>> M ['X', [1, 2, 3], 'Y'] 308 | Chapter 9: Tuples, Files, and Everything Else
- 361. >>> L[1] = 0 # Changes M too >>> M ['X', [1, 0, 3], 'Y'] This effect usually becomes important only in larger programs, and shared references are often exactly what you want. If objects change out from under you in unwanted ways, you can avoid sharing objects by copying them explicitly. For lists, you can always make a top-level copy by using an empty-limits slice, among other techniques described earlier: >>> L = [1, 2, 3] >>> M = ['X', L[:], 'Y'] # Embed a copy of L (or list(L), or L.copy()) >>> L[1] = 0 # Changes only L, not M >>> L [1, 0, 3] >>> M ['X', [1, 2, 3], 'Y'] Remember, slice limits default to 0 and the length of the sequence being sliced; if both are omitted, the slice extracts every item in the sequence and so makes a top-level copy (a new, unshared object). Repetition Adds One Level Deep Repeating a sequence is like adding it to itself a number of times. However, when mutable sequences are nested, the effect might not always be what you expect. For instance, in the following example X is assigned to L repeated four times, whereas Y is assigned to a list containing L repeated four times: >>> L = [4, 5, 6] >>> X = L * 4 # Like [4, 5, 6] + [4, 5, 6] + ... >>> Y = [L] * 4 # [L] + [L] + ... = [L, L,...] >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] Because L was nested in the second repetition, Y winds up embedding references back to the original list assigned to L, and so is open to the same sorts of side effects noted in the preceding section: >>> L[1] = 0 # Impacts Y but not X >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]] This may seem artificial and academic—until it happens unexpectedly in your code! The same solutions to this problem apply here as in the previous section, as this is really just another way to create the shared mutable object reference case—make copies when you don’t want shared references: Built-in Type Gotchas | 309
- 362. >>> L = [4, 5, 6] >>> Y = [list(L)] * 4 # Embed a (shared) copy of L >>> L[1] = 0 >>> Y [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] Even more subtly, although Y doesn’t share an object with L anymore, it still embeds four references to the same copy of it. If you must avoid that sharing too, you’ll want to make sure each embedded copy is unique: >>> Y[0][1] = 99 # All four copies are still the same >>> Y [[4, 99, 6], [4, 99, 6], [4, 99, 6], [4, 99, 6]] >>> L = [4, 5, 6] >>> Y = [list(L) for i in range(4)] >>> Y [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] >>> Y[0][1] = 99 >>> Y [[4, 99, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] If you remember that repetition, concatenation, and slicing copy only the top level of their operand objects, these sorts of cases make much more sense. Beware of Cyclic Data Structures We actually encountered this concept in a prior exercise: if a collection object contains a reference to itself, it’s called a cyclic object. Python prints a [...] whenever it detects a cycle in the object, rather than getting stuck in an infinite loop (as it once did long ago): >>> L = ['grail'] # Append reference to same object >>> L.append(L) # Generates cycle in object: [...] >>> L ['grail', [...]] Besides understanding that the three dots in square brackets represent a cycle in the object, this case is worth knowing about because it can lead to gotchas—cyclic struc- tures may cause code of your own to fall into unexpected loops if you don’t anticipate them. For instance, some programs that walk through structured data must keep a list, dic- tionary, or set of already visited items, and check it when they’re about to step into a cycle that could cause an unwanted loop. See the solutions to the “Test Your Knowl- edge: Part I Exercises” on page 87 in Appendix D for more on this problem. Also watch for general discussion of recursion in Chapter 19, as well as the reloadall.py program in Chapter 25 and the ListTree class in Chapter 31, for concrete examples of programs where cycle detection can matter. The solution is knowledge: don’t use cyclic references unless you really need to, and make sure you anticipate them in programs that must care. There are good reasons to 310 | Chapter 9: Tuples, Files, and Everything Else
- 363. create cycles, but unless you have code that knows how to handle them, objects that reference themselves may be more surprise than asset. Immutable Types Can’t Be Changed in Place And once more for completeness: you can’t change an immutable object in place. In- stead, you construct a new object with slicing, concatenation, and so on, and assign it back to the original reference, if needed: T = (1, 2, 3) T[2] = 4 # Error! T = T[:2] + (4,) # OK: (1, 2, 4) That might seem like extra coding work, but the upside is that the previous gotchas in this section can’t happen when you’re using immutable objects such as tuples and strings; because they can’t be changed in place, they are not open to the sorts of side effects that lists are. Chapter Summary This chapter explored the last two major core object types—the tuple and the file. We learned that tuples support all the usual sequence operations, have just a few methods, do not allow any in-place changes because they are immutable, and are extended by the named tuple type. We also learned that files are returned by the built-in open func- tion and provide methods for reading and writing data. Along the way we explored how to translate Python objects to and from strings for storing in files, and we looked at the pickle, json, and struct modules for advanced roles (object serialization and binary data). Finally, we wrapped up by reviewing some properties common to all object types (e.g., shared references) and went through a list of common mistakes (“gotchas”) in the object type domain. In the next part of this book, we’ll shift gears, turning to the topic of statement syntax— the way you code processing logic in your scripts. Along the way, this next part explores all of Python’s basic procedural statements. The next chapter kicks off this topic with an introduction to Python’s general syntax model, which is applicable to all statement types. Before moving on, though, take the chapter quiz, and then work through the end-of-part lab exercises to review type concepts. Statements largely just create and process objects, so make sure you’ve mastered this domain by working through all the exercises before reading on. Test Your Knowledge: Quiz 1. How can you determine how large a tuple is? Why is this tool located where it is? Test Your Knowledge: Quiz | 311
- 364. 2. Write an expression that changes the first item in a tuple. (4, 5, 6) should become (1, 5, 6) in the process. 3. What is the default for the processing mode argument in a file open call? 4. What module might you use to store Python objects in a file without converting them to strings yourself? 5. How might you go about copying all parts of a nested structure at once? 6. When does Python consider an object true? 7. What is your quest? Test Your Knowledge: Answers 1. The built-in len function returns the length (number of contained items) for any container object in Python, including tuples. It is a built-in function instead of a type method because it applies to many different types of objects. In general, built- in functions and expressions may span many object types; methods are specific to a single object type, though some may be available on more than one type (index, for example, works on lists and tuples). 2. Because they are immutable, you can’t really change tuples in place, but you can generate a new tuple with the desired value. Given T = (4, 5, 6), you can change the first item by making a new tuple from its parts by slicing and concatenating: T = (1,) + T[1:]. (Recall that single-item tuples require a trailing comma.) You could also convert the tuple to a list, change it in place, and convert it back to a tuple, but this is more expensive and is rarely required in practice—simply use a list if you know that the object will require in-place changes. 3. The default for the processing mode argument in a file open call is 'r', for reading text input. For input text files, simply pass in the external file’s name. 4. The pickle module can be used to store Python objects in a file without explicitly converting them to strings. The struct module is related, but it assumes the data is to be in packed binary format in the file; json similarly converts a limited set of Python objects to and from strings per the JSON format. 5. Import the copy module, and call copy.deepcopy(X) if you need to copy all parts of a nested structure X. This is also rarely seen in practice; references are usually the desired behavior, and shallow copies (e.g., aList[:], aDict.copy(), set(aSet)) usually suffice for most copies. 6. An object is considered true if it is either a nonzero number or a nonempty collec- tion object. The built-in words True and False are essentially predefined to have the same meanings as integer 1 and 0, respectively. 7. Acceptable answers include “To learn Python,” “To move on to the next part of the book,” or “To seek the Holy Grail.” 312 | Chapter 9: Tuples, Files, and Everything Else
- 365. Test Your Knowledge: Part II Exercises This session asks you to get your feet wet with built-in object fundamentals. As before, a few new ideas may pop up along the way, so be sure to flip to the answers in Appen- dix D when you’re done (or even when you’re not). If you have limited time, I suggest starting with exercises 10 and 11 (the most practical of the bunch), and then working from first to last as time allows. This is all fundamental material, so try to do as many of these as you can; programming is a hands-on activity, and there is no substitute for practicing what you’ve read to make ideas gel. 1. The basics. Experiment interactively with the common type operations found in the various operation tables in this part of the book. To get started, bring up the Python interactive interpreter, type each of the following expressions, and try to explain what’s happening in each case. Note that the semicolon in some of these is being used as a statement separator, to squeeze multiple statements onto a single line: for example, X=1;X assigns and then prints a variable (more on statement syntax in the next part of the book). Also remember that a comma between ex- pressions usually builds a tuple, even if there are no enclosing parentheses: X,Y,Z is a three-item tuple, which Python prints back to you in parentheses. 2 ** 16 2 / 5, 2 / 5.0 "spam" + "eggs" S = "ham" "eggs " + S S * 5 S[:0] "green %s and %s" % ("eggs", S) 'green {0} and {1}'.format('eggs', S) ('x',)[0] ('x', 'y')[1] L = [1,2,3] + [4,5,6] L, L[:], L[:0], L[−2], L[−2:] ([1,2,3] + [4,5,6])[2:4] [L[2], L[3]] L.reverse(); L L.sort(); L L.index(4) {'a':1, 'b':2}['b'] D = {'x':1, 'y':2, 'z':3} D['w'] = 0 D['x'] + D['w'] D[(1,2,3)] = 4 list(D.keys()), list(D.values()), (1,2,3) in D [[]], ["",[],(),{},None] Test Your Knowledge: Part II Exercises | 313
- 366. 2. Indexing and slicing. At the interactive prompt, define a list named L that contains four strings or numbers (e.g., L=[0,1,2,3]). Then, experiment with the following boundary cases. You may never see these cases in real programs (especially not in the bizarre ways they appear here!), but they are intended to make you think about the underlying model, and some may be useful in less artificial forms—slicing out of bounds can help, for example, if a sequence is as long as you expect: a. What happens when you try to index out of bounds (e.g., L[4])? b. What about slicing out of bounds (e.g., L[−1000:100])? c. Finally, how does Python handle it if you try to extract a sequence in reverse, with the lower bound greater than the higher bound (e.g., L[3:1])? Hint: try assigning to this slice (L[3:1]=['?']), and see where the value is put. Do you think this may be the same phenomenon you saw when slicing out of bounds? 3. Indexing, slicing, and del. Define another list L with four items, and assign an empty list to one of its offsets (e.g., L[2]=[]). What happens? Then, assign an empty list to a slice (L[2:3]=[]). What happens now? Recall that slice assignment deletes the slice and inserts the new value where it used to be. The del statement deletes offsets, keys, attributes, and names. Use it on your list to delete an item (e.g., del L[0]). What happens if you delete an entire slice (del L[1:])? What happens when you assign a nonsequence to a slice (L[1:2]=1)? 4. Tuple assignment. Type the following lines: >>> X = 'spam' >>> Y = 'eggs' >>> X, Y = Y, X What do you think is happening to X and Y when you type this sequence? 5. Dictionary keys. Consider the following code fragments: >>> D = {} >>> D[1] = 'a' >>> D[2] = 'b' You’ve learned that dictionaries aren’t accessed by offsets, so what’s going on here? Does the following shed any light on the subject? (Hint: strings, integers, and tuples share which type category?) >>> D[(1, 2, 3)] = 'c' >>> D {1: 'a', 2: 'b', (1, 2, 3): 'c'} 6. Dictionary indexing. Create a dictionary named D with three entries, for keys 'a', 'b', and 'c'. What happens if you try to index a nonexistent key (D['d'])? What does Python do if you try to assign to a nonexistent key 'd' (e.g., D['d']='spam')? How does this compare to out-of-bounds assignments and references for lists? Does this sound like the rule for variable names? 7. Generic operations. Run interactive tests to answer the following questions: 314 | Chapter 9: Tuples, Files, and Everything Else
- 367. a. What happens when you try to use the + operator on different/mixed types (e.g., string + list, list + tuple)? b. Does + work when one of the operands is a dictionary? c. Does the append method work for both lists and strings? How about using the keys method on lists? (Hint: what does append assume about its subject object?) d. Finally, what type of object do you get back when you slice or concatenate two lists or two strings? 8. String indexing. Define a string S of four characters: S = "spam". Then type the followingexpression:S[0][0][0][0][0].Anyclueastowhat’shappeningthistime? (Hint: recall that a string is a collection of characters, but Python characters are one-character strings.) Does this indexing expression still work if you apply it to a list such as ['s', 'p', 'a', 'm']? Why? 9. Immutable types. Define a string S of four characters again: S = "spam". Write an assignment that changes the string to "slam", using only slicing and concatenation. Could you perform the same operation using just indexing and concatenation? How about index assignment? 10. Nesting. Write a data structure that represents your personal information: name (first, middle, last), age, job, address, email address, and phone number. You may build the data structure with any combination of built-in object types you like (lists, tuples, dictionaries, strings, numbers). Then, access the individual components of your data structures by indexing. Do some structures make more sense than others for this object? 11. Files. Write a script that creates a new output file called myfile.txt and writes the string "Hello file world!" into it. Then write another script that opens my- file.txt and reads and prints its contents. Run your two scripts from the system command line. Does the new file show up in the directory where you ran your scripts? What if you add a different directory path to the filename passed to open? Note: file write methods do not add newline characters to your strings; add an explicit n at the end of the string if you want to fully terminate the line in the file. Test Your Knowledge: Part II Exercises | 315
- 369. PART III Statements and Syntax
- 371. CHAPTER 10 Introducing Python Statements Now that you’re familiar with Python’s core built-in object types, this chapter begins our exploration of its fundamental statement forms. As in the previous part, we’ll begin here with a general introduction to statement syntax, and we’ll follow up with more details about specific statements in the next few chapters. In simple terms, statements are the things you write to tell Python what your programs should do. If, as suggested in Chapter 4, programs “do things with stuff,” then state- ments are the way you specify what sort of things a program does. Less informally, Python is a procedural, statement-based language; by combining statements, you spec- ify a procedure that Python performs to satisfy a program’s goals. The Python Conceptual Hierarchy Revisited Another way to understand the role of statements is to revisit the concept hierarchy introduced in Chapter 4, which talked about built-in objects and the expressions used to manipulate them. This chapter climbs the hierarchy to the next level of Python program structure: 1. Programs are composed of modules. 2. Modules contain statements. 3. Statements contain expressions. 4. Expressions create and process objects. At their base, programs written in the Python language are composed of statements and expressions. Expressions process objects and are embedded in statements. State- ments code the larger logic of a program’s operation—they use and direct expressions to process the objects we studied in the preceding chapters. Moreover, statements are where objects spring into existence (e.g., in expressions within assignment statements), and some statements create entirely new kinds of objects (functions, classes, and so on). At the top, statements always exist in modules, which themselves are managed with statements. 319
- 372. Python’s Statements Table 10-1 summarizes Python’s statement set. Each statement in Python has its own specific purpose and its own specific syntax—the rules that define its structure— though, as we’ll see, many share common syntax patterns, and some statements’ roles overlap. Table 10-1 also gives examples of each statement, when coded according to its syntax rules. In your programs, these units of code can perform actions, repeat tasks, make choices, build larger program structures, and so on. This part of the book deals with entries in the table from the top through break and continue. You’ve informally been introduced to a few of the statements in Table 10-1 already; this part of the book will fill in details that were skipped earlier, introduce the rest of Python’s procedural statement set, and cover the overall syntax model. State- ments lower in Table 10-1 that have to do with larger program units—functions, classes, modules, and exceptions—lead to larger programming ideas, so they will each have a section of their own. More focused statements (like del, which deletes various components) are covered elsewhere in the book, or in Python’s standard manuals. Table 10-1. Python statements Statement Role Example Assignment Creating references a, b = 'good', 'bad' Calls and other expressions Running functions log.write("spam, ham") print calls Printing objects print('The Killer', joke) if/elif/else Selecting actions if "python" in text: print(text) for/else Iteration for x in mylist: print(x) while/else General loops while X > Y: print('hello') pass Empty placeholder while True: pass break Loop exit while True: if exittest(): break continue Loop continue while True: if skiptest(): continue def Functions and methods def f(a, b, c=1, *d): print(a+b+c+d[0]) return Functions results def f(a, b, c=1, *d): return a+b+c+d[0] yield Generator functions def gen(n): for i in n: yield i*2 global Namespaces x = 'old' def function(): global x, y; x = 'new' nonlocal Namespaces (3.X) def outer(): x = 'old' 320 | Chapter 10: Introducing Python Statements
- 373. Statement Role Example def function(): nonlocal x; x = 'new' import Module access import sys from Attribute access from sys import stdin class Building objects class Subclass(Superclass): staticData = [] def method(self): pass try/except/ finally Catching exceptions try: action() except: print('action error') raise Triggering exceptions raise EndSearch(location) assert Debugging checks assert X > Y, 'X too small' with/as Context managers (3.X, 2.6+) with open('data') as myfile: process(myfile) del Deleting references del data[k] del data[i:j] del obj.attr del variable Technically, Table 10-1 reflects Python 3.X’s statements. Though sufficient as a quick preview and reference, it’s not quite complete as is. Here are a few fine points about its content: • Assignment statements come in a variety of syntax flavors, described in Chap- ter 11: basic, sequence, augmented, and more. • print is technically neither a reserved word nor a statement in 3.X, but a built-in function call; because it will nearly always be run as an expression statement, though (and often on a line by itself), it’s generally thought of as a statement type. We’ll study print operations in Chapter 11. • yield is also an expression instead of a statement as of 2.5; like print, it’s typically used as an expression statement and so is included in this table, but scripts occa- sionally assign or otherwise use its result, as we’ll see in Chapter 20. As an expres- sion, yield is also a reserved word, unlike print. Most of this table applies to Python 2.X, too, except where it doesn’t—if you are using Python 2.X, here are a few notes for your Python, too: • In 2.X, nonlocal is not available; as we’ll see in Chapter 17, there are alternative ways to achieve this statement’s writeable state-retention effect. • In 2.X, print is a statement instead of a built-in function call, with specific syntax covered in Chapter 11. • In 2.X, the 3.X exec code execution built-in function is a statement, with specific syntax; since it supports enclosing parentheses, though, you can generally use its 3.X call form in 2.X code. Python’s Statements | 321
- 374. • In 2.5, the try/except and try/finally statements were merged: the two were for- merly separate statements, but we can now say both except and finally in the same try statement. • In 2.5, with/as is an optional extension, and it is not available unless you explicitly turn it on by running the statement from __future__ import with_statement (see Chapter 34). A Tale of Two ifs Before we delve into the details of any of the concrete statements in Table 10-1, I want to begin our look at Python statement syntax by showing you what you are not going to type in Python code so you can compare and contrast it with other syntax models you might have seen in the past. Consider the following if statement, coded in a C-like language: if (x > y) { x = 1; y = 2; } This might be a statement in C, C++, Java, JavaScript, or similar. Now, look at the equivalent statement in the Python language: if x > y: x = 1 y = 2 The first thing that may pop out at you is that the equivalent Python statement is less, well, cluttered—that is, there are fewer syntactic components. This is by design; as a scripting language, one of Python’s goals is to make programmers’ lives easier by re- quiring less typing. More specifically, when you compare the two syntax models, you’ll notice that Python adds one new thing to the mix, and that three items that are present in the C-like language are not present in Python code. What Python Adds The one new syntax component in Python is the colon character (:). All Python com- pound statements—statements that have other statements nested inside them—follow the same general pattern of a header line terminated in a colon, followed by a nested block of code usually indented underneath the header line, like this: Header line: Nested statement block The colon is required, and omitting it is probably the most common coding mistake among new Python programmers—it’s certainly one I’ve witnessed thousands of times 322 | Chapter 10: Introducing Python Statements
- 375. in Python training classes I’ve taught. In fact, if you are new to Python, you’ll almost certainly forget the colon character very soon. You’ll get an error message if you do, and most Python-friendly editors make this mistake easy to spot. Including it eventually becomes an unconscious habit (so much so that you may start typing colons in your C-like language code, too, generating many entertaining error messages from that lan- guage’s compiler!). What Python Removes Although Python requires the extra colon character, there are three things programmers in C-like languages must include that you don’t generally have to in Python. Parentheses are optional The first of these is the set of parentheses around the tests at the top of the statement: if (x < y) The parentheses here are required by the syntax of many C-like languages. In Python, though, they are not—we simply omit the parentheses, and the statement works the same way: if x < y Technically speaking, because every expression can be enclosed in parentheses, in- cluding them will not hurt in this Python code, and they are not treated as an error if present. But don’t do that: you’ll be wearing out your keyboard needlessly, and broadcasting to the world that you’re a programmer of a C-like language still learning Python (I know, because I was once, too). The “Python way” is to simply omit the parentheses in these kinds of statements altogether. End-of-line is end of statement The second and more significant syntax component you won’t find in Python code is the semicolon. You don’t need to terminate statements with semicolons in Python the way you do in C-like languages: x = 1; In Python, the general rule is that the end of a line automatically terminates the state- ment that appears on that line. In other words, you can leave off the semicolons, and it works the same way: x = 1 There are some ways to work around this rule, as you’ll see in a moment (for instance, wrapping code in a bracketed structure allows it to span lines). But, in general, you A Tale of Two ifs | 323
- 376. write one statement per line for the vast majority of Python code, and no semicolon is required. Here, too, if you are pining for your C programming days (if such a state is possible) you can continue to use semicolons at the end of each statement—the language lets you get away with them if they are present, because the semicolon is also a separator when statements are combined. But don’t do that either (really!). Again, doing so tells the world that you’re a program- mer of a C-like language who still hasn’t quite made the switch to Python coding. The Pythonic style is to leave off the semicolons altogether. Judging from students in classes, this seems a tough habit for some veteran programmers to break. But you’ll get there; semicolons are useless noise in this role in Python. End of indentation is end of block The third and final syntax component that Python removes, and the one that may seem the most unusual to soon-to-be-ex-programmers of C-like languages (until they’ve used it for 10 minutes and realize it’s actually a feature), is that you do not type anything explicit in your code to syntactically mark the beginning and end of a nested block of code. You don’t need to include begin/end, then/endif, or braces around the nested block, as you do in C-like languages: if (x > y) { x = 1; y = 2; } Instead, in Python, we consistently indent all the statements in a given single nested block the same distance to the right, and Python uses the statements’ physical inden- tation to determine where the block starts and stops: if x > y: x = 1 y = 2 By indentation, I mean the blank whitespace all the way to the left of the two nested statements here. Python doesn’t care how you indent (you may use either spaces or tabs), or how much you indent (you may use any number of spaces or tabs). In fact, the indentation of one nested block can be totally different from that of another. The syntax rule is only that for a given single nested block, all of its statements must be indented the same distance to the right. If this is not the case, you will get a syntax error, and your code will not run until you repair its indentation to be consistent. Why Indentation Syntax? The indentation rule may seem unusual at first glance to programmers accustomed to C-like languages, but it is a deliberate feature of Python, and it’s one of the main ways that Python almost forces programmers to produce uniform, regular, and readable 324 | Chapter 10: Introducing Python Statements
- 377. code. It essentially means that you must line up your code vertically, in columns, ac- cording to its logical structure. The net effect is to make your code more consistent and readable (unlike much of the code written in C-like languages). To put that more strongly, aligning your code according to its logical structure is a major part of making it readable, and thus reusable and maintainable, by yourself and others. In fact, even if you never use Python after reading this book, you should get into the habit of aligning your code for readability in any block-structured language. Python underscores the issue by making this a part of its syntax, but it’s an important thing to do in any programming language, and it has a huge impact on the usefulness of your code. Your experience may vary, but when I was still doing development on a full-time basis, I was mostly paid to work on large old C++ programs that had been worked on by many programmers over the years. Almost invariably, each programmer had his or her own style for indenting code. For example, I’d often be asked to change a while loop coded in the C++ language that began like this: while (x > 0) { Before we even get into indentation, there are three or four ways that programmers can arrange these braces in a C-like language, and organizations often endure political bat- tles and standards manuals to address the options (which seems more than a little off- topic for the problem to be solved by programming). Be that as it may, here’s the scenario I often encountered in C++ code. The first person who worked on the code indented the loop four spaces: while (x > 0) { --------; --------; That person eventually moved on to management, only to be replaced by someone who liked to indent further to the right: while (x > 0) { --------; --------; --------; --------; That person later moved on to other opportunities (ending that individual’s reign of coding terror...), and someone else picked up the code who liked to indent less: while (x > 0) { --------; --------; --------; --------; --------; --------; } A Tale of Two ifs | 325
- 378. And so on. Eventually, the block is terminated by a closing brace (}), which of course makes this “block-structured code” (he says, sarcastically). No: in any block-structured language, Python or otherwise, if nested blocks are not indented consistently, they become very difficult for the reader to interpret, change, or reuse, because the code no longer visually reflects its logical meaning. Readability matters, and indentation is a major component of readability. Here is another example that may have burned you in the past if you’ve done much programming in a C-like language. Consider the following statement in C: if (x) if (y) statement1; else statement2; Which if does the else here go with? Surprisingly, the else is paired with the nested if statement (if (y)) in C, even though it looks visually as though it is associated with the outer if (x). This is a classic pitfall in the C language, and it can lead to the reader completely misinterpreting the code and changing it incorrectly in ways that might not be uncovered until the Mars rover crashes into a giant rock! This cannot happen in Python—because indentation is significant, the way the code looks is the way it will work. Consider an equivalent Python statement: if x: if y: statement1 else: statement2 In this example, the if that the else lines up with vertically is the one it is associated with logically (the outer if x). In a sense, Python is a WYSIWYG language—what you see is what you get—because the way code looks is the way it runs, regardless of who coded it. If this still isn’t enough to underscore the benefits of Python’s syntax, here’s another anecdote. Early in my career, I worked at a successful company that developed systems software in the C language, where consistent indentation is not required. Even so, when we checked our code into source control at the end of the day, this company ran an automated script that analyzed the indentation used in the code. If the script noticed that we’d indented our code inconsistently, we received an automated email about it the next morning—and so did our managers! The point is that even when a language doesn’t require it, good programmers know that consistent use of indentation has a huge impact on code readability and quality. The fact that Python promotes this to the level of syntax is seen by most as a feature of the language. Also keep in mind that nearly every programmer-friendly text editor has built-in sup- port for Python’s syntax model. In the IDLE Python GUI, for example, lines of code 326 | Chapter 10: Introducing Python Statements
- 379. are automatically indented when you are typing a nested block; pressing the Backspace key backs up one level of indentation, and you can customize how far to the right IDLE indents statements in a nested block. There is no universal standard on this: four spaces or one tab per level is common, but it’s generally up to you to decide how and how much you wish to indent (unless you work at a company that’s endured politics and manuals to standardize this too). Indent further to the right for further nested blocks, and less to close the prior block. As a rule of thumb, you probably shouldn’t mix tabs and spaces in the same block in Python, unless you do so consistently; use tabs or spaces in a given block, but not both (in fact, Python 3.X now issues an error for inconsistent use of tabs and spaces, as we’ll see in Chapter 12). Then again, you probably shouldn’t mix tabs or spaces in inden- tation in any structured language—such code can cause major readability issues if the next programmer has his or her editor set to display tabs differently than yours. C-like languages might let coders get away with this, but they shouldn’t: the result can be a mangled mess. Regardless of which language you code in, you should be indenting consistently for readability. In fact, if you weren’t taught to do this earlier in your career, your teachers did you a disservice. Most programmers—especially those who must read others’ code —consider it a major asset that Python elevates this to the level of syntax. Moreover, generating tabs instead of braces is no more difficult in practice for tools that must output Python code. In general, if you do what you should be doing in a C-like language anyhow, but get rid of the braces, your code will satisfy Python’s syntax rules. A Few Special Cases As mentioned previously, in Python’s syntax model: • The end of a line terminates the statement on that line (without semicolons). • Nested statements are blocked and associated by their physical indentation (without braces). Those rules cover almost all Python code you’ll write or see in practice. However, Python also provides some special-purpose rules that allow customization of both statements and nested statement blocks. They’re not required and should be used sparingly, but programmers have found them useful in practice. Statement rule special cases Although statements normally appear one per line, it is possible to squeeze more than one statement onto a single line in Python by separating them with semicolons: a = 1; b = 2; print(a + b) # Three statements on one line This is the only place in Python where semicolons are required: as statement separa- tors. This only works, though, if the statements thus combined are not themselves A Tale of Two ifs | 327
- 380. compound statements. In other words, you can chain together only simple statements, like assignments, prints, and function calls. Compound statements like if tests and while loops must still appear on lines of their own (otherwise, you could squeeze an entire program onto one line, which probably would not make you very popular among your coworkers!). The other special rule for statements is essentially the inverse: you can make a single statement span across multiple lines. To make this work, you simply have to enclose part of your statement in a bracketed pair—parentheses (()), square brackets ([]), or curly braces ({}). Any code enclosed in these constructs can cross multiple lines: your statement doesn’t end until Python reaches the line containing the closing part of the pair. For instance, to continue a list literal: mylist = [1111, 2222, 3333] Because the code is enclosed in a square brackets pair, Python simply drops down to the next line until it encounters the closing bracket. The curly braces surrounding dic- tionaries (as well as set literals and dictionary and set comprehensions in 3.X and 2.7) allow them to span lines this way too, and parentheses handle tuples, function calls, and expressions. The indentation of the continuation lines does not matter, though common sense dictates that the lines should be aligned somehow for readability. Parentheses are the catchall device—because any expression can be wrapped in them, simply inserting a left parenthesis allows you to drop down to the next line and continue your statement: X = (A + B + C + D) This technique works with compound statements, too, by the way. Anywhere you need to code a large expression, simply wrap it in parentheses to continue it on the next line: if (A == 1 and B == 2 and C == 3): print('spam' * 3) An older rule also allows for continuation lines when the prior line ends in a backslash: X = A + B + C + D # An error-prone older alternative This alternative technique is dated, though, and is frowned on today because it’s dif- ficult to notice and maintain the backslashes. It’s also fairly brittle and error-prone— there can be no spaces after the backslash, and accidentally omitting it can have unex- pected effects if the next line is mistaken to be a new statement (in this example, “C + D” is a valid statement by itself if it’s not indented). This rule is also another throwback to the C language, where it is commonly used in “#define” macros; again, when in Pythonland, do as Pythonistas do, not as C programmers do. 328 | Chapter 10: Introducing Python Statements
- 381. Block rule special case As mentioned previously, statements in a nested block of code are normally associated by being indented the same amount to the right. As one special case here, the body of a compound statement can instead appear on the same line as the header in Python, after the colon: if x > y: print(x) This allows us to code single-line if statements, single-line while and for loops, and so on. Here again, though, this will work only if the body of the compound statement itself does not contain any compound statements. That is, only simple statements— assignments, prints, function calls, and the like—are allowed after the colon. Larger statements must still appear on lines by themselves. Extra parts of compound state- ments (such as the else part of an if, which we’ll meet in the next section) must also be on separate lines of their own. Compound statement bodies can also consist of multiple simple statements separated by semicolons, but this tends to be frowned upon. In general, even though it’s not always required, if you keep all your statements on individual lines and always indent your nested blocks, your code will be easier to read and change in the future. Moreover, some code profiling and coverage tools may not be able to distinguish between multiple statements squeezed onto a single line or the header and body of a one-line compound statement. It is almost always to your ad- vantage to keep things simple in Python. You can use the special-case exceptions to write Python code that’s hard to read, but it takes a lot of work, and there are probably better ways to spend your time. To see a prime and common exception to one of these rules in action, however (the use of a single-line if statement to break out of a loop), and to introduce more of Python’s syntax, let’s move on to the next section and write some real code. A Quick Example: Interactive Loops We’ll see all these syntax rules in action when we tour Python’s specific compound statements in the next few chapters, but they work the same everywhere in the Python language. To get started, let’s work through a brief, realistic example that demonstrates the way that statement syntax and statement nesting come together in practice, and introduces a few statements along the way. A Simple Interactive Loop Suppose you’re asked to write a Python program that interacts with a user in a console window. Maybe you’re accepting inputs to send to a database, or reading numbers to be used in a calculation. Regardless of the purpose, you need to code a loop that reads one or more inputs from a user typing on a keyboard, and prints back a result for each. In other words, you need to write a classic read/evaluate/print loop program. A Quick Example: Interactive Loops | 329
- 382. In Python, typical boilerplate code for such an interactive loop might look like this: while True: reply = input('Enter text:') if reply == 'stop': break print(reply.upper()) This code makes use of a few new ideas and some we’ve already seen: • The code leverages the Python while loop, Python’s most general looping state- ment. We’ll study the while statement in more detail later, but in short, it consists of the word while, followed by an expression that is interpreted as a true or false result, followed by a nested block of code that is repeated while the test at the top is true (the word True here is considered always true). • The input built-in function we met earlier in the book is used here for general console input—it prints its optional argument string as a prompt and returns the user’s typed reply as a string. Use raw_input in 2.X instead, per the upcoming note. • A single-line if statement that makes use of the special rule for nested blocks also appears here: the body of the if appears on the header line after the colon instead of being indented on a new line underneath it. This would work either way, but as it’s coded, we’ve saved an extra line. • Finally, the Python break statement is used to exit the loop immediately—it simply jumps out of the loop statement altogether, and the program continues after the loop. Without this exit statement, the while would loop forever, as its test is always true. In effect, this combination of statements essentially means “read a line from the user and print it in uppercase until the user enters the word ‘stop.’” There are other ways to code such a loop, but the form used here is very common in Python code. Notice that all three lines nested under the while header line are indented the same amount—because they line up vertically in a column this way, they are the block of code that is associated with the while test and repeated. Either the end of the source file or a lesser-indented statement will suffice to terminate the loop body block. When this code is run, either interactively or as a script file, here is the sort of interaction we get—all of the code for this example is ininteract.py in the book’s examples package: Enter text:spam SPAM Enter text:42 42 Enter text:stop 330 | Chapter 10: Introducing Python Statements
- 383. Version skew note: This example is coded for Python 3.X. If you are working in Python 2.X, the code works the same, but you must use raw_input instead of input in all of this chapter’s examples, and you can omit the outer parentheses in print statements (though they don’t hurt). In fact, if you study the interact.py file in the examples package, you’ll see that it does this automatically—to support 2.X compatibility, it re- sets input if the running Python’s major version is 2 (“input” winds up running raw_input): import sys if sys.version[0] == '2': input = raw_input # 2.X compatible In 3.X, raw_input was renamed input, and print is a built-in function instead of a statement (more on prints in the next chapter). Python 2.X has an input too, but it tries to evaluate the input string as though it were Python code, which probably won’t work in this context; eval(input()) can yield the same effect 3.X. Doing Math on User Inputs Our script works, but now suppose that instead of converting a text string to uppercase, we want to do some math with numeric input—squaring it, for example, perhaps in some misguided effort of an age-input program to tease its users. We might try state- ments like these to achieve the desired effect: >>> reply = '20' >>> reply ** 2 ...error text omitted... TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int' This won’t quite work in our script, though, because (as discussed in the prior part of the book) Python won’t convert object types in expressions unless they are all numeric, and input from a user is always returned to our script as a string. We cannot raise a string of digits to a power unless we convert it manually to an integer: >>> int(reply) ** 2 400 Armed with this information, we can now recode our loop to perform the necessary math. Type the following in a file to test it: while True: reply = input('Enter text:') if reply == 'stop': break print(int(reply) ** 2) print('Bye') This script uses a single-line if statement to exit on “stop” as before, but it also converts inputs to perform the required math. This version also adds an exit message at the bottom. Because the print statement in the last line is not indented as much as the A Quick Example: Interactive Loops | 331
- 384. nested block of code, it is not considered part of the loop body and will run only once, after the loop is exited: Enter text:2 4 Enter text:40 1600 Enter text:stop Bye Usage note: From this point on I’ll assume that this code is stored in and run from a script file, via command line, IDLE menu option, or any of the other file launching techniques we met in Chapter 3. Again, it’s named interact.py in the book’s examples. If you are entering this code interactively, though, be sure to include a blank line (i.e., press Enter twice) before the final print statement, to terminate the loop. This im- plies that you also can’t cut and paste the code in its entirety into an interactive prompt: an extra blank line is required interactively, but not in script files. The final print doesn’t quite make sense in interactive mode, though—you’ll have to code it after interacting with the loop! Handling Errors by Testing Inputs So far so good, but notice what happens when the input is invalid: Enter text:xxx ...error text omitted... ValueError: invalid literal for int() with base 10: 'xxx' The built-in int function raises an exception here in the face of a mistake. If we want our script to be robust, we can check the string’s content ahead of time with the string object’s isdigit method: >>> S = '123' >>> T = 'xxx' >>> S.isdigit(), T.isdigit() (True, False) This also gives us an excuse to further nest the statements in our example. The following new version of our interactive script uses a full-blown if statement to work around the exception on errors: while True: reply = input('Enter text:') if reply == 'stop': break elif not reply.isdigit(): print('Bad!' * 8) else: print(int(reply) ** 2) print('Bye') 332 | Chapter 10: Introducing Python Statements
- 385. We’ll study the if statement in more detail in Chapter 12, but it’s a fairly lightweight tool for coding logic in scripts. In its full form, it consists of the word if followed by a test and an associated block of code, one or more optional elif (“else if”) tests and code blocks, and an optional else part, with an associated block of code at the bottom to serve as a default. Python runs the block of code associated with the first test that is true, working from top to bottom, or the else part if all tests are false. The if, elif, and else parts in the preceding example are associated as part of the same statement because they all line up vertically (i.e., share the same level of indentation). The if statement spans from the word if to the start of the print statement on the last line of the script. In turn, the entire if block is part of the while loop because all of it is indented under the loop’s header line. Statement nesting like this is natural once you get the hang of it. When we run our new script, its code catches errors before they occur and prints an error message before continuing (which you’ll probably want to improve in a later release), but “stop” still gets us out, and valid numbers are still squared: Enter text:5 25 Enter text:xyz Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad! Enter text:10 100 Enter text:stop Handling Errors with try Statements The preceding solution works, but as you’ll see later in the book, the most general way to handle errors in Python is to catch and recover from them completely using the Python try statement. We’ll explore this statement in depth in Part VII of this book, but as a preview, using a try here can lead to code that some would see as simpler than the prior version: while True: reply = input('Enter text:') if reply == 'stop': break try: num = int(reply) except: print('Bad!' * 8) else: print(num ** 2) print('Bye') This version works exactly like the previous one, but we’ve replaced the explicit error check with code that assumes the conversion will work and wraps it in an exception handler for cases when it doesn’t. In other words, rather than detecting an error, we simply respond if one occurs. A Quick Example: Interactive Loops | 333
- 386. This try statement is another compound statement, and follows the same pattern as if and while. It’s composed of the word try, followed by the main block of code (the action we are trying to run), followed by an except part that gives the exception handler code and an else part to be run if no exception is raised in the try part. Python first runs the try part, then runs either the except part (if an exception occurs) or the else part (if no exception occurs). In terms of statement nesting, because the words try, except, and else are all indented to the same level, they are all considered part of the same single try statement. Notice that the else part is associated with the try here, not the if. As we’ve seen, else can appear in if statements in Python, but it can also appear in try statements and loops —its indentation tells you what statement it is a part of. In this case, the try statement spans from the word try through the code indented under the word else, because the else is indented the same as try. The if statement in this code is a one-liner and ends after the break. Supporting floating-point numbers Again, we’ll come back to the try statement later in this book. For now, be aware that because try can be used to intercept any error, it reduces the amount of error-checking code you have to write, and it’s a very general approach to dealing with unusual cases. If we’re sure that print won’t fail, for instance, this example could be even more concise: while True: reply = input('Enter text:') if reply == 'stop': break try: print(int(reply) ** 2) except: print('Bad!' * 8) print('Bye') And if we wanted to support input of floating-point numbers instead of just integers, for example, using try would be much easier than manual error testing—we could simply run a float call and catch its exceptions: while True: reply = input('Enter text:') if reply == 'stop': break try: print(float(reply) ** 2) except: print('Bad!' * 8) print('Bye') There is no isfloat for strings today, so this exception-based approach spares us from having to analyze all possible floating-point syntax in an explicit error check. When coding this way, we can enter a wider variety of numbers, but errors and exits still work as before: 334 | Chapter 10: Introducing Python Statements
- 387. Enter text:50 2500.0 Enter text:40.5 1640.25 Enter text:1.23E-100 1.5129e-200 Enter text:spam Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad! Enter text:stop Bye Python’s eval call, which we used in Chapter 5 and Chapter 9 to convert data in strings and files, would work in place of float here too, and would allow input of arbitrary expressions (“2 ** 100” would be a legal, if curious, input, especially if we’re assuming the program is processing ages!). This is a powerful concept that is open to the same security issues mentioned in the prior chapters. If you can’t trust the source of a code string, use more restrictive conversion tools like int and float. Python’s exec, used in Chapter 3 to run code read from a file, is similar to eval (but assumes the string is a statement instead of an expression and has no result), and its compile call precompiles frequently used code strings to bytecode objects for speed. Run a help on any of these for more details; as mentioned, exec is a statement in 2.X but a function in 3.X, so see its manual entry in 2.X instead. We’ll also use exec to import modules by namestring inChapter 25—an example ofitsmoredynamic roles. Nesting Code Three Levels Deep Let’s look at one last mutation of our code. Nesting can take us even further if we need it to—we could, for example, extend our prior integer-only script to branch to one of a set of alternatives based on the relative magnitude of a valid input: while True: reply = input('Enter text:') if reply == 'stop': break elif not reply.isdigit(): print('Bad!' * 8) else: num = int(reply) if num < 20: print('low') else: print(num ** 2) print('Bye') This version adds an if statement nested in the else clause of another if statement, which is in turn nested in the while loop. When code is conditional or repeated like A Quick Example: Interactive Loops | 335
- 388. this, we simply indent it further to the right. The net effect is like that of prior versions, but we’ll now print “low” for numbers less than 20: Enter text:19 low Enter text:20 400 Enter text:spam Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad! Enter text:stop Bye Chapter Summary That concludes our quick look at Python statement syntax. This chapter introduced the general rules for coding statements and blocks of code. As you’ve learned, in Python we normally code one statement per line and indent all the statements in a nested block the same amount (indentation is part of Python’s syntax). However, we also looked at a few exceptions to these rules, including continuation lines and single-line tests and loops. Finally, we put these ideas to work in an interactive script that demonstrated a handful of statements and showed statement syntax in action. In the next chapter, we’ll start to dig deeper by going over each of Python’s basic pro- cedural statements in depth. As you’ll see, though, all statements follow the same gen- eral rules introduced here. Test Your Knowledge: Quiz 1. What three things are required in a C-like language but omitted in Python? 2. How is a statement normally terminated in Python? 3. How are the statements in a nested block of code normally associated in Python? 4. How can you make a single statement span multiple lines? 5. How can you code a compound statement on a single line? 6. Is there any valid reason to type a semicolon at the end of a statement in Python? 7. What is a try statement for? 8. What is the most common coding mistake among Python beginners? Test Your Knowledge: Answers 1. C-like languages require parentheses around the tests in some statements, semi- colons at the end of each statement, and braces around a nested block of code. 2. The end of a line terminates the statement that appears on that line. Alternatively, if more than one statement appears on the same line, they can be terminated with 336 | Chapter 10: Introducing Python Statements
- 389. semicolons; similarly, if a statement spans many lines, you must terminate it by closing a bracketed syntactic pair. 3. Thestatementsinanestedblockareallindentedthesamenumberoftabsorspaces. 4. You can make a statement span many lines by enclosing part of it in parentheses, square brackets, or curly braces; the statement ends when Python sees a line that contains the closing part of the pair. 5. The body of a compound statement can be moved to the header line after the colon, but only if the body consists of only noncompound statements. 6. Only when you need to squeeze more than one statement onto a single line of code. Even then, this only works if all the statements are noncompound, and it’s dis- couraged because it can lead to code that is difficult to read. 7. The try statement is used to catch and recover from exceptions (errors) in a Python script. It’s usually an alternative to manually checking for errors in your code. 8. Forgetting to type the colon character at the end of the header line in a compound statement is the most common beginner’s mistake. If you’re new to Python and haven’t made it yet, you probably will soon! Test Your Knowledge: Answers | 337
- 391. CHAPTER 11 Assignments, Expressions, and Prints Now that we’ve had a quick introduction to Python statement syntax, this chapter begins our in-depth tour of specific Python statements. We’ll begin with the basics: assignment statements, expression statements, and print operations. We’ve already seen all of these in action, but here we’ll fill in important details we’ve skipped so far. Although they’re relatively simple, as you’ll see, there are optional variations for each of these statement types that will come in handy once you begin writing realistic Python programs. Assignment Statements We’ve been using the Python assignment statement for a while to assign objects to names. In its basic form, you write the target of an assignment on the left of an equals sign, and the object to be assigned on the right. The target on the left may be a name or object component, and the object on the right can be an arbitrary expression that computes an object. For the most part, assignments are straightforward, but here are a few properties to keep in mind: • Assignments create object references. As discussed in Chapter 6, Python as- signments store references to objects in names or data structure components. They always create references to objects instead of copying the objects. Because of that, Python variables are more like pointers than data storage areas. • Names are created when first assigned. Python creates a variable name the first time you assign it a value (i.e., an object reference), so there’s no need to predeclare names ahead of time. Some (but not all) data structure slots are created when assigned, too (e.g., dictionary entries, some object attributes). Once assigned, a name is replaced with the value it references whenever it appears in an expression. • Names must be assigned before being referenced. It’s an error to use a name to which you haven’t yet assigned a value. Python raises an exception if you try, rather than returning some sort of ambiguous default value. This turns out to be crucial in Python because names are not predeclared—if Python provided default 339
- 392. values for unassigned names used in your program instead of treating them as errors, it would be much more difficult for you to spot name typos in your code. • Some operations perform assignments implicitly. In this section we’re con- cerned with the = statement, but assignment occurs in many contexts in Python. For instance, we’ll see later that module imports, function and class definitions, for loop variables, and function arguments are all implicit assignments. Because assignment works the same everywhere it pops up, all these contexts simply bind names to object references at runtime. Assignment Statement Forms Although assignment is a general and pervasive concept in Python, we are primarily interested in assignment statements in this chapter. Table 11-1 illustrates the different assignment statement forms in Python, and their syntax patterns. Table 11-1. Assignment statement forms Operation Interpretation spam = 'Spam' Basic form spam, ham = 'yum', 'YUM' Tuple assignment (positional) [spam, ham] = ['yum', 'YUM'] List assignment (positional) a, b, c, d = 'spam' Sequence assignment, generalized a, *b = 'spam' Extended sequence unpacking (Python 3.X) spam = ham = 'lunch' Multiple-target assignment spams += 42 Augmented assignment (equivalent to spams = spams + 42) The first form in Table 11-1 is by far the most common: binding a name (or data struc- ture component) to a single object. In fact, you could get all your work done with this basic form alone. The other table entries represent special forms that are all optional, but that programmers often find convenient in practice: Tuple- and list-unpacking assignments The second and third forms in the table are related. When you code a tuple or list on the left side of the =, Python pairs objects on the right side with targets on the left by position and assigns them from left to right. For example, in the second line of Table 11-1, the name spam is assigned the string 'yum', and the name ham is bound to the string 'YUM'. In this case Python internally may make a tuple of the items on the right, which is why this is called tuple-unpacking assignment. Sequence assignments In later versions of Python, tuple and list assignments were generalized into in- stances of what we now call sequence assignment—any sequence of names can be assigned to any sequence of values, and Python assigns the items one at a time by position. We can even mix and match the types of the sequences involved. The 340 | Chapter 11: Assignments, Expressions, and Prints
- 393. fourth line in Table 11-1, for example, pairs a tuple of names with a string of characters: a is assigned 's', b is assigned 'p', and so on. Extended sequence unpacking In Python 3.X (only), a new form of sequence assignment allows us to be more flexible in how we select portions of a sequence to assign. The fifth line in Ta- ble 11-1, for example, matches a with the first character in the string on the right and b with the rest: a is assigned 's', and b is assigned 'pam'. This provides a simpler alternative to assigning the results of manual slicing operations. Multiple-target assignments The sixth line in Table 11-1 shows the multiple-target form of assignment. In this form, Python assigns a reference to the same object (the object farthest to the right) to all the targets on the left. In the table, the names spam and ham are both assigned references to the same string object, 'lunch'. The effect is the same as if we had coded ham = 'lunch' followed by spam = ham, as ham evaluates to the original string object (i.e., not a separate copy of that object). Augmented assignments The last line in Table 11-1 is an example of augmented assignment—a shorthand that combines an expression and an assignment in a concise way. Saying spam += 42, for example, has the same effect as spam = spam + 42, but the augmented form requires less typing and is generally quicker to run. In addition, if the subject is mutable and supports the operation, an augmented assignment may run even quicker by choosing an in-place update operation instead of an object copy. There is one augmented assignment statement for every binary expression operator in Python. Sequence Assignments We’ve already used and explored basic assignments in this book, so we’ll take them as a given. Here are a few simple examples of sequence-unpacking assignments in action: % python >>> nudge = 1 # Basic assignment >>> wink = 2 >>> A, B = nudge, wink # Tuple assignment >>> A, B # Like A = nudge; B = wink (1, 2) >>> [C, D] = [nudge, wink] # List assignment >>> C, D (1, 2) Notice that we really are coding two tuples in the third line in this interaction—we’ve just omitted their enclosing parentheses. Python pairs the values in the tuple on the right side of the assignment operator with the variables in the tuple on the left side and assigns the values one at a time. Assignment Statements | 341
- 394. Tuple assignment leads to a common coding trick in Python that was introduced in a solution to the exercises at the end of Part II. Because Python creates a temporary tuple that saves the original values of the variables on the right while the statement runs, unpacking assignments are also a way to swap two variables’ values without creating a temporary variable of your own—the tuple on the right remembers the prior values of the variables automatically: >>> nudge = 1 >>> wink = 2 >>> nudge, wink = wink, nudge # Tuples: swaps values >>> nudge, wink # Like T = nudge; nudge = wink; wink = T (2, 1) In fact, the original tuple and list assignment forms in Python have been generalized to accept any type of sequence (really, iterable) on the right as long as it is of the same length as the sequence on the left. You can assign a tuple of values to a list of variables, a string of characters to a tuple of variables, and so on. In all cases, Python assigns items in the sequence on the right to variables in the sequence on the left by position, from left to right: >>> [a, b, c] = (1, 2, 3) # Assign tuple of values to list of names >>> a, c (1, 3) >>> (a, b, c) = "ABC" # Assign string of characters to tuple >>> a, c ('A', 'C') Technically speaking, sequence assignment actually supports any iterable object on the right, not just any sequence. This is a more general category that includes collections both physical (e.g., lists) and virtual (e.g., a file’s lines), which was defined briefly in Chapter 4 and has popped up in passing ever since. We’ll firm up this term when we explore iterables in Chapter 14 and Chapter 20. Advanced sequence assignment patterns Althoughwecanmixandmatchsequencetypesaroundthe= symbol,wemustgenerally have the same number of items on the right as we have variables on the left, or we’ll get an error. Python 3.X allows us to be more general with extended unpacking * syntax, described in the next section. But normally in 3.X—and always in 2.X—the number of items in the assignment target and subject must match: >>> string = 'SPAM' >>> a, b, c, d = string # Same number on both sides >>> a, d ('S', 'M') >>> a, b, c = string # Error if not ...error text omitted... ValueError: too many values to unpack (expected 3) 342 | Chapter 11: Assignments, Expressions, and Prints
- 395. To be more flexible, we can slice in both 2.X and 3.X. There are a variety of ways to employ slicing to make this last case work: >>> a, b, c = string[0], string[1], string[2:] # Index and slice >>> a, b, c ('S', 'P', 'AM') >>> a, b, c = list(string[:2]) + [string[2:]] # Slice and concatenate >>> a, b, c ('S', 'P', 'AM') >>> a, b = string[:2] # Same, but simpler >>> c = string[2:] >>> a, b, c ('S', 'P', 'AM') >>> (a, b), c = string[:2], string[2:] # Nested sequences >>> a, b, c ('S', 'P', 'AM') As the last example in this interaction demonstrates, we can even assign nested se- quences, and Python unpacks their parts according to their shape, as expected. In this case, we are assigning a tuple of two items, where the first item is a nested sequence (a string), exactly as though we had coded it this way: >>> ((a, b), c) = ('SP', 'AM') # Paired by shape and position >>> a, b, c ('S', 'P', 'AM') Python pairs the first string on the right ('SP') with the first tuple on the left ((a, b)) and assigns one character at a time, before assigning the entire second string ('AM') to the variable c all at once. In this event, the sequence-nesting shape of the object on the left must match that of the object on the right. Nested sequence assignment like this is somewhat rare to see, but it can be convenient for picking out the parts of data struc- tures with known shapes. Forexample,we’llseeinChapter13thatthistechniquealsoworksinfor loops,because loop items are assigned to the target given in the loop header: for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: ... # Simple tuple assignment for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: ... # Nested tuple assignment In a note in Chapter 18, we’ll also see that this nested tuple (really, sequence) unpacking assignment form works for function argument lists in Python 2.X (though not in 3.X), because function arguments are passed by assignment as well: def f(((a, b), c)): ... # For arguments too in Python 2.X, but not 3.X f(((1, 2), 3)) Sequence-unpacking assignments also give rise to another common coding idiom in Python—assigning an integer series to a set of variables: Assignment Statements | 343
- 396. >>> red, green, blue = range(3) >>> red, blue (0, 2) This initializes the three names to the integer codes0, 1, and 2, respectively (it’s Python’s equivalent of the enumerated data types you may have seen in other languages). To make sense of this, you need to know that the range built-in function generates a list of successive integers (in 3.X only, it requires a list around it if you wish to display its values all at once like this): >>> list(range(3)) # list() required in Python 3.X only [0, 1, 2] This call was previewed briefly in Chapter 4; because range is commonly used in for loops, we’ll say more about it in Chapter 13. Another place you may see a tuple assignment at work is for splitting a sequence into its front and the rest in loops like this: >>> L = [1, 2, 3, 4] >>> while L: ... front, L = L[0], L[1:] # See next section for 3.X * alternative ... print(front, L) ... 1 [2, 3, 4] 2 [3, 4] 3 [4] 4 [] The tuple assignment in the loop here could be coded as the following two lines instead, but it’s often more convenient to string them together: ... front = L[0] ... L = L[1:] Notice that this code is using the list as a sort of stack data structure, which can often also be achieved with the append and pop methods of list objects; here, front = L.pop(0) would have much the same effect as the tuple assignment statement, but it would be an in-place change. We’ll learn more about while loops, and other (often better) ways to step through a sequence with for loops, in Chapter 13. Extended Sequence Unpacking in Python 3.X The prior section demonstrated how to use manual slicing to make sequence assign- ments more general. In Python 3.X (but not 2.X), sequence assignment has been gen- eralized to make this easier. In short, a single starred name, *X, can be used in the assignment target in order to specify a more general matching against the sequence— the starred name is assigned a list, which collects all items in the sequence not assigned to other names. This is especially handy for common coding patterns such as splitting a sequence into its “front” and “rest,” as in the preceding section’s last example. 344 | Chapter 11: Assignments, Expressions, and Prints
- 397. Extended unpacking in action Let’s look at an example. As we’ve seen, sequence assignments normally require exactly as many names in the target on the left as there are items in the subject on the right. We get an error if the lengths disagree in both 2.X and 3.X (unless we manually sliced on the right, as shown in the prior section): C:code> c:python33python >>> seq = [1, 2, 3, 4] >>> a, b, c, d = seq >>> print(a, b, c, d) 1 2 3 4 >>> a, b = seq ValueError: too many values to unpack (expected 2) In Python 3.X, though, we can use a single starred name in the target to match more generally. In the following continuation of our interactive session, a matches the first item in the sequence, and b matches the rest: >>> a, *b = seq >>> a 1 >>> b [2, 3, 4] When a starred name is used, the number of items in the target on the left need not match the length of the subject sequence. In fact, the starred name can appear anywhere in the target. For instance, in the next interaction b matches the last item in the se- quence, and a matches everything before the last: >>> *a, b = seq >>> a [1, 2, 3] >>> b 4 When the starred name appears in the middle, it collects everything between the other names listed. Thus, in the following interaction a and c are assigned the first and last items, and b gets everything in between them: >>> a, *b, c = seq >>> a 1 >>> b [2, 3] >>> c 4 More generally, wherever the starred name shows up, it will be assigned a list that collects every unassigned name at that position: >>> a, b, *c = seq >>> a Assignment Statements | 345
- 398. 1 >>> b 2 >>> c [3, 4] Naturally, like normal sequence assignment, extended sequence unpacking syntax works for any sequence types (really, again, any iterable), not just lists. Here it is un- packing characters in a string and a range (an iterable in 3.X): >>> a, *b = 'spam' >>> a, b ('s', ['p', 'a', 'm']) >>> a, *b, c = 'spam' >>> a, b, c ('s', ['p', 'a'], 'm') >>> a, *b, c = range(4) >>> a, b, c (0, [1, 2], 3) This is similar in spirit to slicing, but not exactly the same—a sequence unpacking assignment always returns a list for multiple matched items, whereas slicing returns a sequence of the same type as the object sliced: >>> S = 'spam' >>> S[0], S[1:] # Slices are type-specific, * assignment always returns a list ('s', 'pam') >>> S[0], S[1:3], S[3] ('s', 'pa', 'm') Given this extension in 3.X, as long as we’re processing a list the last example of the prior section becomes even simpler, since we don’t have to manually slice to get the first and rest of the items: >>> L = [1, 2, 3, 4] >>> while L: ... front, *L = L # Get first, rest without slicing ... print(front, L) ... 1 [2, 3, 4] 2 [3, 4] 3 [4] 4 [] Boundary cases Although extended sequence unpacking is flexible, some boundary cases are worth noting. First, the starred name may match just a single item, but is always assigned a list: >>> seq = [1, 2, 3, 4] 346 | Chapter 11: Assignments, Expressions, and Prints
- 399. >>> a, b, c, *d = seq >>> print(a, b, c, d) 1 2 3 [4] Second, if there is nothing left to match the starred name, it is assigned an empty list, regardless of where it appears. In the following, a, b, c, and d have matched every item in the sequence, but Python assigns e an empty list instead of treating this as an error case: >>> a, b, c, d, *e = seq >>> print(a, b, c, d, e) 1 2 3 4 [] >>> a, b, *e, c, d = seq >>> print(a, b, c, d, e) 1 2 3 4 [] Finally, errors can still be triggered if there is more than one starred name, if there are too few values and no star (as before), and if the starred name is not itself coded inside a sequence: >>> a, *b, c, *d = seq SyntaxError: two starred expressions in assignment >>> a, b = seq ValueError: too many values to unpack (expected 2) >>> *a = seq SyntaxError: starred assignment target must be in a list or tuple >>> *a, = seq >>> a [1, 2, 3, 4] A useful convenience Keep in mind that extended sequence unpacking assignment is just a convenience. We can usually achieve the same effects with explicit indexing and slicing (and in fact must in Python 2.X), but extended unpacking is simpler to code. The common “first, rest” splitting coding pattern, for example, can be coded either way, but slicing involves extra work: >>> seq [1, 2, 3, 4] >>> a, *b = seq # First, rest >>> a, b (1, [2, 3, 4]) >>> a, b = seq[0], seq[1:] # First, rest: traditional >>> a, b (1, [2, 3, 4]) Assignment Statements | 347
- 400. The also-common “rest, last” splitting pattern can similarly be coded either way, but the new extended unpacking syntax requires noticeably fewer keystrokes: >>> *a, b = seq # Rest, last >>> a, b ([1, 2, 3], 4) >>> a, b = seq[:-1], seq[-1] # Rest, last: traditional >>> a, b ([1, 2, 3], 4) Because it is not only simpler but, arguably, more natural, extended sequence unpack- ing syntax will likely become widespread in Python code over time. Application to for loops Because the loop variable in the for loop statement can be any assignment target, ex- tended sequence assignment works here too. We met the for loop iteration tool briefly in Chapter 4 and will study it formally in Chapter 13. In Python 3.X, extended assign- ments mayshow up afterthewordfor,whereasimplevariablenameismorecommonly used: for (a, *b, c) in [(1, 2, 3, 4), (5, 6, 7, 8)]: ... When used in this context, on each iteration Python simply assigns the next tuple of values to the tuple of names. On the first loop, for example, it’s as if we’d run the following assignment statement: a, *b, c = (1, 2, 3, 4) # b gets [2, 3] The names a, b, and c can be used within the loop’s code to reference the extracted components. In fact, this is really not a special case at all, but just an instance of general assignment at work. As we saw earlier in this chapter, we can do the same thing with simple tuple assignment in both Python 2.X and 3.X: for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: # a, b, c = (1, 2, 3), ... And we can always emulate 3.X’s extended assignment behavior in 2.X by manually slicing: for all in [(1, 2, 3, 4), (5, 6, 7, 8)]: a, b, c = all[0], all[1:3], all[3] Since we haven’t learned enough to get more detailed about the syntax of for loops, we’ll return to this topic in Chapter 13. Multiple-Target Assignments A multiple-target assignment simply assigns all the given names to the object all the way to the right. The following, for example, assigns the three variables a, b, and c to the string 'spam': 348 | Chapter 11: Assignments, Expressions, and Prints
- 401. >>> a = b = c = 'spam' >>> a, b, c ('spam', 'spam', 'spam') This form is equivalent to (but easier to code than) these three assignments: >>> c = 'spam' >>> b = c >>> a = b Multiple-target assignment and shared references Keep in mind that there is just one object here, shared by all three variables (they all wind up pointing to the same object in memory). This behavior is fine for immutable types—for example, when initializing a set of counters to zero (recall that variables must be assigned before they can be used in Python, so you must initialize counters to zero before you can start adding to them): >>> a = b = 0 >>> b = b + 1 >>> a, b (0, 1) Here, changing b only changes b because numbers do not support in-place changes. As long as the object assigned is immutable, it’s irrelevant if more than one name references it. As usual, though, we have to be more cautious when initializing variables to an empty mutable object such as a list or dictionary: >>> a = b = [] >>> b.append(42) >>> a, b ([42], [42]) This time, because a and b reference the same object, appending to it in place through b will impact what we see through a as well. This is really just another example of the shared reference phenomenon we first met in Chapter 6. To avoid the issue, initialize mutable objects in separate statements instead, so that each creates a distinct empty object by running a distinct literal expression: >>> a = [] >>> b = [] # a and b do not share the same object >>> b.append(42) >>> a, b ([], [42]) A tuple assignment like the following has the same effect—by running two list expres- sions, it creates two distinct objects: >>> a, b = [], [] # a and b do not share the same object Assignment Statements | 349
- 402. Augmented Assignments Beginning with Python 2.0, the set of additional assignment statement formats listed in Table 11-2 became available. Known as augmented assignments, and borrowed from the C language, these formats are mostly just shorthand. They imply the combination of a binary expression and an assignment. For instance, the following two formats are roughly equivalent: X = X + Y # Traditional form X += Y # Newer augmented form Table 11-2. Augmented assignment statements X += Y X &= Y X −= Y X |= Y X *= Y X ^= Y X /= Y X >>= Y X %= Y X <<= Y X **= Y X //= Y Augmented assignment works on any type that supports the implied binary expression. For example, here are two ways to add 1 to a name: >>> x = 1 >>> x = x + 1 # Traditional >>> x 2 >>> x += 1 # Augmented >>> x 3 When applied to a sequence such as a string, the augmented form performs concate- nation instead. Thus, the second line here is equivalent to typing the longer S = S + "SPAM": >>> S = "spam" >>> S += "SPAM" # Implied concatenation >>> S 'spamSPAM' As shown in Table 11-2, there are analogous augmented assignment forms for every Python binary expression operator (i.e., each operator with values on the left and right side). For instance, X *= Y multiplies and assigns, X >>= Y shifts right and assigns, and so on. X //= Y (for floor division) was added in version 2.2. Augmented assignments have three advantages:1 • There’s less for you to type. Need I say more? • The left side has to be evaluated only once. In X += Y, X may be a complicated object expression. In the augmented form, its code must be run only once. However, in 1. C/C++ programmers take note: although Python now supports statements like X += Y, it still does not have C’s auto-increment/decrement operators (e.g., X++, −−X). These don’t quite map to the Python object model because Python has no notion of in-place changes to immutable objects like numbers. 350 | Chapter 11: Assignments, Expressions, and Prints
- 403. the long form, X = X + Y, X appears twice and must be run twice. Because of this, augmented assignments usually run faster. • The optimal technique is automatically chosen. That is, for objects that support in-place changes, the augmented forms automatically perform in-place change op- erations instead of slower copies. The last point here requires a bit more explanation. For augmented assignments, in- place operations may be applied for mutable objects as an optimization. Recall that lists can be extended in a variety of ways. To add a single item to the end of a list, we can concatenate or call append: >>> L = [1, 2] >>> L = L + [3] # Concatenate: slower >>> L [1, 2, 3] >>> L.append(4) # Faster, but in place >>> L [1, 2, 3, 4] And to add a set of items to the end, we can either concatenate again or call the list extend method:2 >>> L = L + [5, 6] # Concatenate: slower >>> L [1, 2, 3, 4, 5, 6] >>> L.extend([7, 8]) # Faster, but in place >>> L [1, 2, 3, 4, 5, 6, 7, 8] In both cases, concatenation is less prone to the side effects of shared object references but will generally run slower than the in-place equivalent. Concatenation operations must create a new object, copy in the list on the left, and then copy in the list on the right. By contrast, in-place method calls simply add items at the end of a memory block (it can be a bit more complicated than that internally, but this description suffices). When we use augmented assignment to extend a list, we can largely forget these details —Python automatically calls the quicker extend method instead of using the slower concatenation operation implied by +: >>> L += [9, 10] # Mapped to L.extend([9, 10]) >>> L [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Note however, that because of this equivalence += for a list is not exactly the same as a + and = in all cases—for lists += allows arbitrary sequences (just like extend), but con- catenation normally does not: >>> L = [] >>> L += 'spam' # += and extend allow any sequence, but + does not! 2. As suggested in Chapter 6, we can also use slice assignment (e.g., L[len(L):] = [11,12,13]), but this works roughly the same as the simpler and more mnemonic list extend method. Assignment Statements | 351
- 404. >>> L ['s', 'p', 'a', 'm'] >>> L = L + 'spam' TypeError: can only concatenate list (not "str") to list Augmented assignment and shared references This behavior is usually what we want, but notice that it implies that the += is an in- place change for lists; thus, it is not exactly like + concatenation, which always makes a new object. As for all shared reference cases, this difference might matter if other names reference the object being changed: >>> L = [1, 2] >>> M = L # L and M reference the same object >>> L = L + [3, 4] # Concatenation makes a new object >>> L, M # Changes L but not M ([1, 2, 3, 4], [1, 2]) >>> L = [1, 2] >>> M = L >>> L += [3, 4] # But += really means extend >>> L, M # M sees the in-place change too! ([1, 2, 3, 4], [1, 2, 3, 4]) This only matters for mutables like lists and dictionaries, and it is a fairly obscure case (at least, until it impacts your code!). As always, make copies of your mutable objects if you need to break the shared reference structure. Variable Name Rules Now that we’ve explored assignment statements, it’s time to get more formal about the use of variable names. In Python, names come into existence when you assign values to them, but there are a few rules to follow when choosing names for the subjects of your programs: Syntax: (underscore or letter) + (any number of letters, digits, or underscores) Variable names must start with an underscore or letter, which can be followed by any number of letters, digits, or underscores. _spam, spam, and Spam_1 are legal names, but 1_Spam, spam$, and @#! are not. Case matters: SPAM is not the same as spam Python always pays attention to case in programs, both in names you create and in reserved words. For instance, the names X and x refer to two different variables. For portability, case also matters in the names of imported module files, even on platforms where the filesystems are case-insensitive. That way, your imports still work after programs are copied to differing platforms. Reserved words are off-limits Names you define cannot be the same as words that mean special things in the Python language. For instance, if you try to use a variable name like class, Python 352 | Chapter 11: Assignments, Expressions, and Prints
- 405. will raise a syntax error, but klass and Class work fine. Table 11-3 lists the words that are currently reserved (and hence off-limits for names of your own) in Python. Table 11-3. Python 3.X reserved words False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise Table 11-3 is specific to Python 3.X. In Python 2.X, the set of reserved words differs slightly: • print is a reserved word, because printing is a statement, not a built-in function (more on this later in this chapter). • exec is a reserved word, because it is a statement, not a built-in function. • nonlocal is not a reserved word because this statement is not available. In older Pythons the story is also more or less the same, with a few variations: • with and as were not reserved until 2.6, when context managers were officially enabled. • yield was not reserved until Python 2.3, when generator functions came online. • yield morphed from statement to expression in 2.5, but it’s still a reserved word, not a built-in function. As you can see, most of Python’s reserved words are all lowercase. They are also all truly reserved—unlike names in the built-in scope that you will meet in the next part of this book, you cannot redefine reserved words by assignment (e.g., and = 1 results in a syntax error).3 Besides being of mixed case, the first three entries in Table 11-3, True, False, and None, are somewhat unusual in meaning—they also appear in the built-in scope of Python described in Chapter 17, and they are technically names assigned to objects. In 3.X they are truly reserved in all other senses, though, and cannot be used for any other purpose in your script other than that of the objects they represent. All the other re- served words are hardwired into Python’s syntax and can appear only in the specific contexts for which they are intended. 3. In standard CPython, at least. Alternative implementations of Python might allow user-defined variable names to be the same as Python reserved words. See Chapter 2 for an overview of alternative implementations, such as Jython. Assignment Statements | 353
- 406. Furthermore, because module names in import statements become variables in your scripts, variable name constraints extend to your module filenames too. For instance, you can code files called and.py and my-code.py and run them as top-level scripts, but you cannot import them: their names without the “.py” extension become variables in your code and so must follow all the variable rules just outlined. Reserved words are off-limits, and dashes won’t work, though underscores will. We’ll revisit this module idea in Part V of this book. Python’s Deprecation Protocol It is interesting to note how reserved word changes are gradually phased into the lan- guage. When a new feature might break existing code, Python normally makes it an option and begins issuing “deprecation” warnings one or more releases before the fea- ture is officially enabled. The idea is that you should have ample time to notice the warnings and update your code before migrating to the new release. This is not true for major new releases like 3.0 (which breaks existing code freely), but it is generally true in other cases. For example, yield was an optional extension in Python 2.2, but is a standard keyword as of 2.3. It is used in conjunction with generator functions. This was one of a small handful of instances where Python broke with backward compatibility. Still, yield was phased in over time: it began generating deprecation warnings in 2.2 and was not en- abled until 2.3. Similarly, in Python 2.6, the words with and as become new reserved words for use in context managers (a newer form of exception handling). These two words are not re- served in 2.5, unless the context manager feature is turned on manually with a from__future__import (discussed later in this book). When used in 2.5, with and as generate warnings about the upcoming change—except in the version of IDLE in Python 2.5, which appears to have enabled this feature for you (that is, using these words as variable names does generate errors in 2.5, but only in its version of the IDLE GUI). Naming conventions Besides these rules, there is also a set of naming conventions—rules that are not required but are followed in normal practice. For instance, because names with two leading and trailing underscores (e.g., __name__) generally have special meaning to the Python in- terpreter, you should avoid this pattern for your own names. Here is a list of the con- ventions Python follows: • Names that begin with a single underscore (_X) are not imported by a from module import * statement (described in Chapter 23). • Names that have two leading and trailing underscores (__X__) are system-defined names that have special meaning to the interpreter. 354 | Chapter 11: Assignments, Expressions, and Prints
- 407. • Names that begin with two underscores and do not end with two more (__X) are localized (“mangled”) to enclosing classes (see the discussion of pseudoprivate attributes in Chapter 31). • The name that is just a single underscore (_) retains the result of the last expression when you are working interactively. In addition to these Python interpreter conventions, there are various other conventions that Python programmers usually follow. For instance, later in the book we’ll see that class names commonly start with an uppercase letter and module names with a low- ercase letter, and that the name self, though not reserved, usually has a special role in classes. In Chapter 17 we’ll also study another, larger category of names known as the built-ins, which are predefined but not reserved (and so can be reassigned: open = 42 works, though sometimes you might wish it didn’t!). Names have no type, but objects do This is mostly review, but remember that it’s crucial to keep Python’s distinction be- tween names and objects clear. As described in Chapter 6, objects have a type (e.g., integer, list) and may be mutable or not. Names (a.k.a. variables), on the other hand, are always just references to objects; they have no notion of mutability and have no associated type information, apart from the type of the object they happen to reference at a given point in time. Thus, it’s OK to assign the same name to different kinds of objects at different times: >>> x = 0 # x bound to an integer object >>> x = "Hello" # Now it's a string >>> x = [1, 2, 3] # And now it's a list Inlaterexamples,you’llseethatthisgenericnatureofnamescanbeadecidedadvantage in Python programming. In Chapter 17, you’ll also learn that names also live in some- thing called a scope, which defines where they can be used; the place where you assign a name determines where it is visible.4 For additional naming suggestions, see the discussion of naming con- ventions in Python’s semi-official style guide, known as PEP 8. This guide is available at http://www.python.org/dev/peps/pep-0008, or via a web search for “Python PEP 8.” Technically, this document formalizes coding standards for Python library code. Though useful, the usual caveats about coding standards apply here. Foronething,PEP8comeswithmoredetailthanyouareprobablyready 4. If you’ve used a more restrictive language like C++, you may be interested to know that there is no notion of C++’s const declaration in Python; certain objects may be immutable, but names can always be assigned. Python also has ways to hide names in classes and modules, but they’re not the same as C++’s declarations (if hiding attributes matters to you, see the coverage of _X module names in Chapter 25, __X class names in Chapter 31, and the Private and Public class decorators example in Chapter 39). Assignment Statements | 355
- 408. for at this point in the book. And frankly, it has become more complex, rigid, and subjective than it may need to be—some of its suggestions are not at all universally accepted or followed by Python programmers doing real work. Moreover, some of the most prominent companies using Python today have adopted coding standards of their own that differ. PEP 8 does codify useful rule-of-thumb Python knowledge, though, and it’s a great read for Python beginners, as long as you take its recom- mendations as guidelines, not gospel. Expression Statements In Python, you can use an expression as a statement, too—that is, on a line by itself. But because the result of the expression won’t be saved, it usually makes sense to do so only if the expression does something useful as a side effect. Expressions are com- monly used as statements in two situations: For calls to functions and methods Some functions and methods do their work without returning a value. Such func- tions are sometimes called procedures in other languages. Because they don’t return values that you might be interested in retaining, you can call these functions with expression statements. For printing values at the interactive prompt Python echoes back the results of expressions typed at the interactive command line. Technically, these are expression statements, too; they serve as a shorthand for typing print statements. Table 11-4 lists some common expression statement forms in Python. Calls to functions and methods are coded with zero or more argument objects (really, expressions that evaluate to objects) in parentheses, after the function/method name. Table 11-4. Common Python expression statements Operation Interpretation spam(eggs, ham) Function calls spam.ham(eggs) Method calls spam Printing variables in the interactive interpreter print(a, b, c, sep='') Printing operations in Python 3.X yield x ** 2 Yielding expression statements The last two entries in Table 11-4 are somewhat special cases—as we’ll see later in this chapter, printing in Python 3.X is a function call usually coded on a line by itself, and the yield operation in generator functions (discussed in Chapter 20) is often coded as a statement as well. Both are really just instances of expression statements. 356 | Chapter 11: Assignments, Expressions, and Prints
- 409. Forinstance,though younormallyruna3.Xprint callon aline byitselfasanexpression statement, it returns a value like any other function call (its return value is None, the default return value for functions that don’t return anything meaningful): >>> x = print('spam') # print is a function call expression in 3.X spam >>> print(x) # But it is coded as an expression statement None Also keep in mind that although expressions can appear as statements in Python, state- ments cannot be used as expressions. A statement that is not an expression must gen- erallyappearonalineallbyitself,notnestedinalargersyntacticstructure.Forexample, Python doesn’t allow you to embed assignment statements (=) in other expressions. The rationale for this is that it avoids common coding mistakes; you can’t accidentally change a variable by typing = when you really mean to use the == equality test. You’ll see how to code around this restriction when you meet the Python while loop in Chap- ter 13. Expression Statements and In-Place Changes This brings up another mistake that is common in Python work. Expression statements are often used to run list methods that change a list in place: >>> L = [1, 2] >>> L.append(3) # Append is an in-place change >>> L [1, 2, 3] However, it’s not unusual for Python newcomers to code such an operation as an as- signment statement instead, intending to assign L to the larger list: >>> L = L.append(4) # But append returns None, not L >>> print(L) # So we lose our list! None This doesn’t quite work, though. Calling an in-place change operation such as append, sort, or reverse on a list always changes the list in place, but these methods do not return the list they have changed; instead, they return the None object. Thus, if you assign such an operation’s result back to the variable name, you effectively lose the list (and it is probably garbage-collected in the process!). The moral of the story is, don’t do this—call in-place change operations without as- signing their results. We’ll revisit this phenomenon in the section “Common Coding Gotchas” on page 463 because it can also appear in the context of some looping state- ments we’ll meet in later chapters. Expression Statements | 357
- 410. Print Operations In Python, print prints things—it’s simply a programmer-friendly interface to the stan- dard output stream. Technically, printing converts one or more objects to their textual representations, adds some minor formatting, and sends the resulting text to either standard output or an- other file-like stream. In a bit more detail, print is strongly bound up with the notions of files and streams in Python: File object methods In Chapter 9, we learned about file object methods that write text (e.g., file.write(str)). Printing operations are similar, but more focused—whereas file write methods write strings to arbitrary files, print writes objects to the stdout stream by default, with some automatic formatting added. Unlike with file meth- ods, there is no need to convert objects to strings when using print operations. Standard output stream The standard output stream (often known as stdout) is simply a default place to send a program’s text output. Along with the standard input and error streams, it’s one of three data connections created when your script starts. The standard output stream is usually mapped to the window where you started your Python program, unless it’s been redirected to a file or pipe in your operating system’s shell. Because the standard output stream is available in Python as the stdout file object in the built-in sys module (i.e., sys.stdout), it’s possible to emulate print with file write method calls. However, print is noticeably easier to use and makes it easy to print text to other files and streams. Printing is also one of the most visible places where Python 3.X and 2.X have diverged. In fact, this divergence is usually the first reason that most 2.X code won’t run un- changed under 3.X. Specifically, the way you code print operations depends on which version of Python you use: • In Python 3.X, printing is a built-in function, with keyword arguments for special modes. • In Python 2.X, printing is a statement with specific syntax all its own. Because this book covers both 3.X and 2.X, we will look at each form in turn here. If you are fortunate enough to be able to work with code written for just one version of Python, feel free to pick the section that is relevant to you. Because your needs may change, however, it probably won’t hurt to be familiar with both cases. Moreover, users of recent Python 2.X releases can also import and use 3.X’s flavor of printing in their Pythons if desired—both for its extra functionality and to ease future migration to 3.X. 358 | Chapter 11: Assignments, Expressions, and Prints
- 411. The Python 3.X print Function Strictly speaking, printing is not a separate statement form in 3.X. Instead, it is simply an instance of the expression statement we studied in the preceding section. The print built-in function is normally called on a line of its own, because it doesn’t return any value we care about (technically, it returns None, as we saw in the preceding section). Because it is a normal function, though, printing in 3.X uses standard function- call syntax, rather than a special statement form. And because it provides special op- eration modes with keyword arguments, this form is both more general and supports future enhancements better. By comparison, Python 2.X print statements have somewhat ad hoc syntax to support extensions such as end-of-line suppression and target files. Further, the 2.X statement does not support separator specification at all; in 2.X, you wind up building strings ahead of time more often than you do in 3.X. Rather than adding yet more ad hoc syntax, Python 3.X’s print takes a single, general approach that covers them all. Call format Syntactically, calls to the 3.X print function have the following form (the flush argu- ment is new as of Python 3.3): print([object, ...][, sep=' '][, end='n'][, file=sys.stdout][, flush=False]) In this formal notation, items in square brackets are optional and may be omitted in a given call, and values after = give argument defaults. In English, this built-in function prints the textual representation of one or more objects separated by the string sep and followed by the string end to the stream file, flushing buffered output or not per flush. Thesep,end,file,and(in3.3andlater)flush parts,ifpresent,mustbegivenaskeyword arguments—that is, you must use a special “name=value” syntax to pass the arguments by name instead of position. Keyword arguments are covered in depth in Chapter 18, but they’re straightforward to use. The keyword arguments sent to this call may appear in any left-to-right order following the objects to be printed, and they control the print operation: • sep is a string inserted between each object’s text, which defaults to a single space if not passed; passing an empty string suppresses separators altogether. • end is a string added at the end of the printed text, which defaults to a n newline character if not passed. Passing an empty string avoids dropping down to the next output line at the end of the printed text—the next print will keep adding to the end of the current output line. • file specifies the file, standard stream, or other file-like object to which the text will be sent; it defaults to the sys.stdout standard output stream if not passed. Any object with a file-like write(string) method may be passed, but real files should be already opened for output. Print Operations | 359
- 412. • flush, added in 3.3, defaults to False. It allows prints to mandate that their text be flushed through the output stream immediately to any waiting recipients. Nor- mally, whether printed output is buffered in memory or not is determined by file; passing a true value to flush forcibly flushes the stream. The textual representation of each object to be printed is obtained by passing the object to the str built-in call (or its equivalent inside Python); as we’ve seen, this built-in returns a “user friendly” display string for any object.5 With no arguments at all, the print function simply prints a newline character to the standard output stream, which usually displays a blank line. The 3.X print function in action Printing in 3.X is probably simpler than some of its details may imply. To illustrate, let’s run some quick examples. The following prints a variety of object types to the default standard output stream, with the default separator and end-of-line formatting added (these are the defaults because they are the most common use case): C:code> c:python33python >>> print() # Display a blank line >>> x = 'spam' >>> y = 99 >>> z = ['eggs'] >>> >>> print(x, y, z) # Print three objects per defaults spam 99 ['eggs'] There’s no need to convert objects to strings here, as would be required for file write methods. By default, print calls add a space between the objects printed. To suppress this, send an empty string to the sep keyword argument, or send an alternative separator of your choosing: >>> print(x, y, z, sep='') # Suppress separator spam99['eggs'] >>> >>> print(x, y, z, sep=', ') # Custom separator spam, 99, ['eggs'] Also by default, print adds an end-of-line character to terminate the output line. You can suppress this and avoid the line break altogether by passing an empty string to the end keyword argument, or you can pass a different terminator of your own including a n character to break the line manually if desired (the second of the following is two statements on one line, separated by a semicolon): 5. Technically, printing uses the equivalent of str in the internal implementation of Python, but the effect is the same. Besides this to-string conversion role, str is also the name of the string data type and can be used to decode Unicode strings from raw bytes with an extra encoding argument, as we’ll learn in Chapter 37; this latter role is an advanced usage that we can safely ignore here. 360 | Chapter 11: Assignments, Expressions, and Prints
- 413. >>> print(x, y, z, end='') # Suppress line break spam 99 ['eggs']>>> >>> >>> print(x, y, z, end=''); print(x, y, z) # Two prints, same output line spam 99 ['eggs']spam 99 ['eggs'] >>> print(x, y, z, end='...n') # Custom line end spam 99 ['eggs']... >>> You can also combine keyword arguments to specify both separators and end-of-line strings—they may appear in any order but must appear after all the objects being printed: >>> print(x, y, z, sep='...', end='!n') # Multiple keywords spam...99...['eggs']! >>> print(x, y, z, end='!n', sep='...') # Order doesn't matter spam...99...['eggs']! Here is how the file keyword argument is used—it directs the printed text to an open output file or other compatible object for the duration of the single print (this is really a form of stream redirection, a topic we will revisit later in this section): >>> print(x, y, z, sep='...', file=open('data.txt', 'w')) # Print to a file >>> print(x, y, z) # Back to stdout spam 99 ['eggs'] >>> print(open('data.txt').read()) # Display file text spam...99...['eggs'] Finally, keep in mind that the separator and end-of-line options provided by print op- erations are just conveniences. If you need to display more specific formatting, don’t print this way. Instead, build up a more complex string ahead of time or within the print itself using the string tools we met in Chapter 7, and print the string all at once: >>> text = '%s: %-.4f, %05d' % ('Result', 3.14159, 42) >>> print(text) Result: 3.1416, 00042 >>> print('%s: %-.4f, %05d' % ('Result', 3.14159, 42)) Result: 3.1416, 00042 As we’ll see in the next section, almost everything we’ve just seen about the 3.X print function also applies directly to 2.X print statements—which makes sense, given that the function was intended to both emulate and improve upon 2.X printingsupport. The Python 2.X print Statement As mentioned earlier, printing in Python 2.X uses a statement with unique and specific syntax, rather than a built-in function. In practice, though, 2.X printing is mostly a variation on a theme; with the exception of separator strings (which are supported in 3.X but not 2.X) and flushes on prints (available as of 3.3 only), everything we can do with the 3.X print function has a direct translation to the 2.X print statement. Print Operations | 361
- 414. Statement forms Table 11-5 lists the print statement’s forms in Python 2.X and gives their Python 3.X print function equivalents for reference. Notice that the comma is significant in print statements—it separates objects to be printed, and a trailing comma suppresses the end-of-line character normally added at the end of the printed text (not to be con- fused with tuple syntax!). The >> syntax, normally used as a bitwise right-shift opera- tion, is used here as well, to specify a target output stream other than the sys.stdout default. Table 11-5. Python 2.X print statement forms Python 2.X statement Python 3.X equivalent Interpretation print x, y print(x, y) Print objects’ textual forms to sys.stdout; add a spacebetweentheitemsandanend-of-lineattheend print x, y, print(x, y, end='') Same, but don’t add end-of-line at end of text print >> afile, x, y print(x, y, file=afile) Send text to afile.write, not to sys.stdout.write The 2.X print statement in action Although the 2.X print statement has more unique syntax than the 3.X function, it’s similarly easy to use. Let’s turn to some basic examples again. The 2.X print statement adds a space between the items separated by commas and by default adds a line break at the end of the current output line: C:code> c:python27python >>> x = 'a' >>> y = 'b' >>> print x, y a b This formatting is just a default; you can choose to use it or not. To suppress the line break so you can add more text to the current line later, end your print statement with a comma, as shown in the second line of Table 11-5 (the following uses a semicolon to separate two statements on one line again): >>> print x, y,; print x, y a b a b To suppress the space between items, again, don’t print this way. Instead, build up an output string using the string concatenation and formatting tools covered in Chap- ter 7, and print the string all at once: >>> print x + y ab >>> print '%s...%s' % (x, y) a...b 362 | Chapter 11: Assignments, Expressions, and Prints
- 415. As you can see, apart from their special syntax for usage modes, 2.X print statements are roughly as simple to use as 3.X’s function. The next section uncovers the way that files are specified in 2.X prints. Print Stream Redirection In both Python 3.X and 2.X, printing sends text to the standard output stream by default. However, it’s often useful to send it elsewhere—to a text file, for example, to save results for later use or testing purposes. Although such redirection can be accom- plished in system shells outside Python itself, it turns out to be just as easy to redirect a script’s streams from within the script. The Python “hello world” program Let’s start off with the usual (and largely pointless) language benchmark—the “hello world” program. To print a “hello world” message in Python, simply print the string per your version’s print operation: >>> print('hello world') # Print a string object in 3.X hello world >>> print 'hello world' # Print a string object in 2.X hello world Because expression results are echoed on the interactive command line, you often don’t even need to use a print statement there—simply type the expressions you’d like to have printed, and their results are echoed back: >>> 'hello world' # Interactive echoes 'hello world' This code isn’t exactly an earth-shattering piece of software mastery, but it serves to illustrate printing behavior. Really, the print operation is just an ergonomic feature of Python—it provides a simple interface to the sys.stdout object, with a bit of default formatting. In fact, if you enjoy working harder than you must, you can also code print operations this way: >>> import sys # Printing the hard way >>> sys.stdout.write('hello worldn') hello world This code explicitly calls the write method of sys.stdout—an attribute preset when Python starts up to an open file object connected to the output stream. The print operation hides most of those details, providing a simple tool for simple printing tasks. Manual stream redirection So, why did I just show you the hard way to print? The sys.stdout print equivalent turns out to be the basis of a common technique in Python. In general, print and sys.stdout are directly related as follows. This statement: Print Operations | 363
- 416. print(X, Y) # Or, in 2.X: print X, Y is equivalent to the longer: import sys sys.stdout.write(str(X) + ' ' + str(Y) + 'n') which manually performs a string conversion with str, adds a separator and newline with +, and calls the output stream’s write method. Which would you rather code? (He says, hoping to underscore the programmer-friendly nature of prints...) Obviously, the long form isn’t all that useful for printing by itself. However, it is useful to know that this is exactly what print operations do because it is possible to reas- signsys.stdout tosomethingdifferentfromthestandardoutputstream.Inotherwords, this equivalence provides a way of making your print operations send their text to other places. For example: import sys sys.stdout = open('log.txt', 'a') # Redirects prints to a file ... print(x, y, x) # Shows up in log.txt Here,weresetsys.stdout toamanuallyopenedfilenamedlog.txt,locatedinthescript’s working directory and opened in append mode (so we add to its current content). After the reset, every print operation anywhere in the program will write its text to the end of the file log.txt instead of to the original output stream. The print operations are happy to keep calling sys.stdout’s write method, no matter what sys.stdout happens to refer to. Because there is just one sys module in your process, assigning sys.stdout this way will redirect every print anywhere in your program. In fact, as the sidebar “Why You Will Care: print and stdout” on page 368 will explain, you can even reset sys.stdout to an object that isn’t a file at all, as long as it has the expected interface: a method named write to receive the printed text string argument. When that object is a class, printed text can be routed and processed arbitrarily per a write method you code yourself. This trick of resetting the output stream might be more useful for programs originally coded with print statements. If you know that output should go to a file to begin with, you can always call file write methods instead. To redirect the output of a print-based program, though, resetting sys.stdout provides a convenient alternative to changing every print statement or using system shell-based redirection syntax. In other roles, streams may be reset to objects that display them in pop-up windows in GUIs, colorize then in IDEs like IDLE, and so on. It’s a general technique. Automatic stream redirection Although redirecting printed text by assigning sys.stdout is a useful tool, a potential problem with the last section’s code is that there is no direct way to restore the original output stream should you need to switch back after printing to a file. Because 364 | Chapter 11: Assignments, Expressions, and Prints
- 417. sys.stdout is just a normal file object, though, you can always save it and restore it if needed:6 C:code> c:python33python >>> import sys >>> temp = sys.stdout # Save for restoring later >>> sys.stdout = open('log.txt', 'a') # Redirect prints to a file >>> print('spam') # Prints go to file, not here >>> print(1, 2, 3) >>> sys.stdout.close() # Flush output to disk >>> sys.stdout = temp # Restore original stream >>> print('back here') # Prints show up here again back here >>> print(open('log.txt').read()) # Result of earlier prints spam 1 2 3 As you can see, though, manual saving and restoring of the original output stream like this involves quite a bit of extra work. Because this crops up fairly often, a print ex- tension is available to make it unnecessary. In 3.X, the file keyword allows a single print call to send its text to the write method of a file (or file-like object), without actually resetting sys.stdout. Because the redirec- tion is temporary, normal print calls keep printing to the original output stream. In 2.X, a print statement that begins with a >> followed by an output file object (or other compatible object) has the same effect. For example, the following again sends printed text to a file named log.txt: log = open('log.txt', 'a') # 3.X print(x, y, z, file=log) # Print to a file-like object print(a, b, c) # Print to original stdout log = open('log.txt', 'a') # 2.X print >> log, x, y, z # Print to a file-like object print a, b, c # Print to original stdout These redirected forms of print are handy if you need to print to both files and the standard output stream in the same program. If you use these forms, however, be sure to give them a file object (or an object that has the same write method as a file object), not a file’s name string. Here is the technique in action: C:code> c:python33python >>> log = open('log.txt', 'w') >>> print(1, 2, 3, file=log) # For 2.X: print >> log, 1, 2, 3 >>> print(4, 5, 6, file=log) >>> log.close() >>> print(7, 8, 9) # For 2.X: print 7, 8, 9 6. In both 2.X and 3.X you may also be able to use the __stdout__ attribute in the sys module, which refers to the original value sys.stdout had at program startup time. You still need to restore sys.stdout to sys.__stdout__ to go back to this original stream value, though. See the sys module documentation for more details. Print Operations | 365
- 418. 7 8 9 >>> print(open('log.txt').read()) 1 2 3 4 5 6 These extended forms of print are also commonly used to print error messages to the standard error stream, available to your script as the preopened file object sys.stderr. You can either use its file write methods and format the output manually, or print with redirection syntax: >>> import sys >>> sys.stderr.write(('Bad!' * 8) + 'n') Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad! >>> print('Bad!' * 8, file=sys.stderr) # In 2.X: print >> sys.stderr, 'Bad!' * 8 Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad! Now that you know all about print redirections, the equivalence between printing and file write methods should be fairly obvious. The following interaction prints both ways in 3.X, then redirects the output to an external file to verify that the same text is printed: >>> X = 1; Y = 2 >>> print(X, Y) # Print: the easy way 1 2 >>> import sys # Print: the hard way >>> sys.stdout.write(str(X) + ' ' + str(Y) + 'n') 1 2 4 >>> print(X, Y, file=open('temp1', 'w')) # Redirect text to file >>> open('temp2', 'w').write(str(X) + ' ' + str(Y) + 'n') # Send to file manually 4 >>> print(open('temp1', 'rb').read()) # Binary mode for bytes b'1 2rn' >>> print(open('temp2', 'rb').read()) b'1 2rn' As you can see, unless you happen to enjoy typing, print operations are usually the best option for displaying text. For another example of the equivalence between prints and file writes, watch for a 3.X print function emulation example in Chapter 18; it uses this code pattern to provide a general 3.X print function equivalent for use in Python 2.X. Version-Neutral Printing Finally, if you need your prints to work on both Python lines, you have some options. This is true whether you’re writing 2.X code that strives for 3.X compatibility, or 3.X code that aims to support 2.X too. 2to3 converter Forone,youcancode2.Xprint statementsandlet3.X’s2to3 conversionscripttranslate them to 3.X function calls automatically. See the Python 3.X manuals for more details 366 | Chapter 11: Assignments, Expressions, and Prints
- 419. about this script; it attempts to translate 2.X code to run under 3.X—a useful tool, but perhaps more than you want to make just your print operations version-neutral. A related tool named 3to2 attempts to do the inverse: convert 3.X code to run on 2.X; see Appendix C for more information. Importing from __future__ Alternatively,youcancode3.Xprint functioncallsincodetoberunby2.X,byenabling the function call variant with a statement like the following coded at the top of a script, or anywhere in an interactive session: from __future__ import print_function This statement changes 2.X to support 3.X’s print functions exactly. This way, you can use 3.X print features and won’t have to change your prints if you later migrate to 3.X. Two usage notes here: • This statement is simply ignored if it appears in code run by 3.X—it doesn’t hurt if included in 3.X code for 2.X compatibility. • This statement must appear at the top of each file that prints in 2.X—because it modifies that parser for a single file only, it’s not enough to import another file that includes this statement. Neutralizing display differences with code Also keep in mind that simple prints, like those in the first row of Table 11-5, work in either version of Python—because any expression may be enclosed in parentheses, we can always pretend to be calling a 3.X print function in 2.X by adding outer parenthe- ses. The main downside to this is that it makes a tuple out of your printed objects if there are more than one, or none—they will print with extra enclosing parentheses. In 3.X, for example, any number of objects may be listed in the call’s parentheses: C:code> c:python33python >>> print('spam') # 3.X print function call syntax spam >>> print('spam', 'ham', 'eggs') # These are multiple arguments spam ham eggs The first of these works the same in 2.X, but the second generates a tuple in the output: C:code> c:python27python >>> print('spam') # 2.X print statement, enclosing parens spam >>> print('spam', 'ham', 'eggs') # This is really a tuple object! ('spam', 'ham', 'eggs') The same applies when there are no objects printed to force a line-feed: 2.X shows a tuple, unless you print an empty string: c:code> py −2 >> print() # This is just a line-feed on 3.X Print Operations | 367
- 420. () >>> print('') # This is a line-feed in both 2.X and 3.X Strictly speaking, outputs may in some cases differ in more than just extra enclosing parentheses in 2.X. If you look closely at the preceding results, you’ll notice that the strings also print with enclosing quotes in 2.X only. This is because objects may print differently when nested in another object than they do as top-level items. Technically, nested appearances display with repr and top-level objects with str—the two alterna- tive display formats we noted in Chapter 5. Here this just means extra quotes around strings nested in the tuple that is created for printing multiple parenthesized items in 2.X. Displays of nested objects can differ much more for other object types, though, and especially for class objects that define alter- native displays with operator overloading—a topic we’ll cover in Part VI in general and Chapter 30 in particular. To be truly portable without enabling 3.X prints everywhere, and to sidestep display difference for nested appearances, you can always format the print string as a single object to unify displays across versions, using the string formatting expression or method call, or other string tools that we studied in Chapter 7: >>> print('%s %s %s' % ('spam', 'ham', 'eggs')) spam ham eggs >>> print('{0} {1} {2}'.format('spam', 'ham', 'eggs')) spam ham eggs >>> print('answer: ' + str(42)) answer: 42 Of course, if you can use 3.X exclusively you can forget such mappings entirely, but many Python programmers will at least encounter, if not write, 2.X code and systems for some time to come. We’ll use both __future__ and version-neutral code to achieve 2.X/3.X portability in many examples in this book. I use Python 3.X print function calls throughout this book. I’ll often make prints version-neutral, and will usually warn you when the results may differ in 2.X, but I sometimes don’t, so please consider this note a blanket warning. If you see extra parentheses in your printed text in 2.X, either drop the parentheses in your print statements, import 3.X prints from the __future__, recode your prints using the version-neutral scheme outlined here, or learn to love superfluous text. Why You Will Care: print and stdout The equivalence between the print operation and writing to sys.stdout is important. It makes it possible to reassign sys.stdout to any user-defined object that provides the same write method as files. Because the print statement just sends text to the sys.stdout.write method, you can capture printed text in your programs by assigning sys.stdout to an object whose write method processes the text in arbitrary ways. 368 | Chapter 11: Assignments, Expressions, and Prints
- 421. For instance, you can send printed text to a GUI window, or tee it off to multiple destinations, by defining an object with a write method that does the required routing. You’ll see an example of this trick when we study classes in Part VI of this book, but abstractly, it looks like this: class FileFaker: def write(self, string): # Do something with printed text in string import sys sys.stdout = FileFaker() print(someObjects) # Sends to class write method This works because print is what we will call in the next part of this book a polymor- phic operation—it doesn’t care what sys.stdout is, only that it has a method (i.e., interface) called write. This redirection to objects is made even simpler with the file keyword argument in 3.X and the >> extended form of print in 2.X, because we don’t need to reset sys.stdout explicitly—normal prints will still be routed to the stdout stream: myobj = FileFaker() # 3.X: Redirect to object for one print print(someObjects, file=myobj) # Does not reset sys.stdout myobj = FileFaker() # 2.X: same effect print >> myobj, someObjects # Does not reset sys.stdout Python’s 3.X’s built-in input function (named raw_input in 2.X) reads from the sys.stdin file, so you can intercept read requests in a similar way, using classes that implement file-like read methods instead. See the input and while loop example in Chapter 10 for more background on this function. Notice that because printed text goes to the stdout stream, it’s also the way to print HTML reply pages in CGI scripts used on the Web, and enables you to redirect Python script input and output at the operating system’s shell command line as usual: python script.py < inputfile > outputfile python script.py | filterProgram Python’s print operation redirection tools are essentially pure-Python alternatives to these shell syntax forms. See other resources for more on CGI scripts and shell syntax. Chapter Summary In this chapter, we began our in-depth look at Python statements by exploring assign- ments, expressions, and print operations. Although these are generally simple to use, they have some alternative forms that, while optional, are often convenient in practice —augmented assignment statements and the redirection form of print operations, for example, allow us to avoid some manual coding work. Along the way, we also studied the syntax of variable names, stream redirection techniques, and a variety of common mistakes to avoid, such as assigning the result of an append method call back to a vari- able. Chapter Summary | 369
- 422. In the next chapter, we’ll continue our statement tour by filling in details about the if statement, Python’s main selection tool; there, we’ll also revisit Python’s syntax model in more depth and look at the behavior of Boolean expressions. Before we move on, though, the end-of-chapter quiz will test your knowledge of what you’ve learned here. Test Your Knowledge: Quiz 1. Name three ways that you can assign three variables to the same value. 2. Why might you need to care when assigning three variables to a mutable object? 3. What’s wrong with saying L = L.sort()? 4. How might you use the print operation to send text to an external file? Test Your Knowledge: Answers 1. You can use multiple-target assignments (A = B = C = 0), sequence assignment (A, B, C = 0, 0, 0), or multiple assignment statements on three separate lines (A = 0, B = 0, and C = 0). With the latter technique, as introduced in Chapter 10, you can also string the three separate statements together on the same line by separating them with semicolons (A = 0; B = 0; C = 0). 2. If you assign them this way: A = B = C = [] all three names reference the same object, so changing it in place from one (e.g., A.append(99)) will affect the others. This is true only for in-place changes to mu- table objects like lists and dictionaries; for immutable objects such as numbers and strings, this issue is irrelevant. 3. The list sort method is like append in that it makes an in-place change to the subject list—it returns None, not the list it changes. The assignment back to L sets L to None, not to the sorted list. As discussed both earlier and later in this book (e.g., Chapter 8), a newer built-in function, sorted, sorts any sequence and returns a new list with the sorting result; because this is not an in-place change, its result can be meaningfully assigned to a name. 4. To print to a file for a single print operation, you can use 3.X’s print(X, file=F) call form, use 2.X’s extended print >> file, X statement form, or assign sys.stdout to a manually opened file before the print and restore the original after. You can also redirect all of a program’s printed text to a file with special syntax in the system shell, but this is outside Python’s scope. 370 | Chapter 11: Assignments, Expressions, and Prints
- 423. CHAPTER 12 if Tests and Syntax Rules This chapter presents the Python if statement, which is the main statement used for selecting from alternative actions based on test results. Because this is our first in-depth look at compound statements—statements that embed other statements—we will also explore the general concepts behind the Python statement syntax model here in more detail than we did in the introduction in Chapter 10. Because the if statement intro- duces the notion of tests, this chapter will also deal with Boolean expressions, cover the “ternary” if expression, and fill in some details on truth tests in general. if Statements In simple terms, the Python if statement selects actions to perform. Along with its expression counterpart, it’s the primary selection tool in Python and represents much of the logic a Python program possesses. It’s also our first compound statement. Like all compound Python statements, the if statement may contain other statements, in- cluding other ifs. In fact, Python lets you combine statements in a program sequentially (so that they execute one after another), and in an arbitrarily nested fashion (so that they execute only under certain conditions such as selections and loops). General Format The Python if statement is typical of if statements in most procedural languages. It takes the form of an if test, followed by one or more optional elif (“else if”) tests and a final optional else block. The tests and the else part each have an associated block of nested statements, indented under a header line. When theif statement runs, Python executes the block of code associated with the first test that evaluates to true, or the else block if all tests prove false. The general form of an if statement looks like this: if test1: # if test statements1 # Associated block elif test2: # Optional elifs statements2 371
- 424. else: # Optional else statements3 Basic Examples To demonstrate, let’s look at a few simple examples of the if statement at work. All parts are optional, except the initial if test and its associated statements. Thus, in the simplest case, the other parts are omitted: >>> if 1: ... print('true') ... true Notice how the prompt changes to ... for continuation lines when you’re typing in- teractively in the basic interface used here; in IDLE, you’ll simply drop down to an indented line instead (hit Backspace to back up). A blank line (which you can get by pressing Enter twice) terminates and runs the entire statement. Remember that 1 is Boolean true (as we’ll see later, the word True is its equivalent), so this statement’s test always succeeds. To handle a false result, code the else: >>> if not 1: ... print('true') ... else: ... print('false') ... false Multiway Branching Now here’s an example of a more complex if statement, with all its optional parts present: >>> x = 'killer rabbit' >>> if x == 'roger': ... print("shave and a haircut") ... elif x == 'bugs': ... print("what's up doc?") ... else: ... print('Run away! Run away!') ... Run away! Run away! This multiline statement extends from the if line through the block nested under the else. When it’s run, Python executes the statements nested under the first test that is true, or the else part if all tests are false (in this example, they are). In practice, both the elif and else parts may be omitted, and there may be more than one statement nested in each section. Note that the words if, elif, and else are associated by the fact that they line up vertically, with the same indentation. 372 | Chapter 12: if Tests and Syntax Rules
- 425. If you’ve used languages like C or Pascal, you might be interested to know that there is no switch or case statement in Python that selects an action based on a variable’s value. Instead, you usually code multiway branching as a series of if/elif tests, as in the prior example, and occasionally by indexing dictionaries or searching lists. Because dictionaries and lists can be built at runtime dynamically, they are sometimes more flexible than hardcoded if logic in your script: >>> choice = 'ham' >>> print({'spam': 1.25, # A dictionary-based 'switch' ... 'ham': 1.99, # Use has_key or get for default ... 'eggs': 0.99, ... 'bacon': 1.10}[choice]) 1.99 Although it may take a few moments for this to sink in the first time you see it, this dictionary is a multiway branch—indexing on the key choice branches to one of a set of values, much like a switch in C. An almost equivalent but more verbose Python if statement might look like the following: >>> if choice == 'spam': # The equivalent if statement ... print(1.25) ... elif choice == 'ham': ... print(1.99) ... elif choice == 'eggs': ... print(0.99) ... elif choice == 'bacon': ... print(1.10) ... else: ... print('Bad choice') ... 1.99 Though it’s perhaps more readable, the potential downside of an if like this is that, short of constructing it as a string and running it with tools like the prior chapter’s eval or exec, you cannot construct it at runtime as easily as a dictionary. In more dy- namic programs, data structures offer added flexibility. Handling switch defaults Notice the else clause on the if here to handle the default case when no key matches. As we saw in Chapter 8, dictionary defaults can be coded with in expressions, get method calls, or exception catching with the try statement introduced in the preceding chapter. All of the same techniques can be used here to code a default action in a dictionary-based multiway branch. As a review in the context of this use case, here’s the get scheme at work with defaults: >>> branch = {'spam': 1.25, ... 'ham': 1.99, ... 'eggs': 0.99} >>> print(branch.get('spam', 'Bad choice')) 1.25 if Statements | 373
- 426. >>> print(branch.get('bacon', 'Bad choice')) Bad choice An in membership test in an if statement can have the same default effect: >>> choice = 'bacon' >>> if choice in branch: ... print(branch[choice]) ... else: ... print('Bad choice') ... Bad choice And the try statement is a general way to handle defaults by catching and handling the exceptions they’d otherwise trigger (for more on exceptions, see Chapter 11’s overview and Part VII’s full treatment): >>> try: ... print(branch[choice]) ... except KeyError: ... print('Bad choice') ... Bad choice Handling larger actions Dictionaries are good for associating values with keys, but what about the more com- plicated actions you can code in the statement blocks associated with if statements? In Part IV, you’ll learn that dictionaries can also contain functions to represent more complex branch actions and implement general jump tables. Such functions appear as dictionary values, they may be coded as function names or inline lambdas, and they are called by adding parentheses to trigger their actions. Here’s an abstract sampler, but stay tuned for a rehash of this topic in Chapter 19 after we’ve learned more about function definition: def function(): ... def default(): ... branch = {'spam': lambda: ..., # A table of callable function objects 'ham': function, 'eggs': lambda: ...} branch.get(choice, default)() Although dictionary-based multiway branching is useful in programs that deal with more dynamic data, most programmers will probably find that coding an if statement is the most straightforward way to perform multiway branching. As a rule of thumb in coding, when in doubt, err on the side of simplicity and readability; it’s the “Pythonic” way. 374 | Chapter 12: if Tests and Syntax Rules
- 427. Python Syntax Revisited I introduced Python’s syntax model in Chapter 10. Now that we’re stepping up to larger statements like if, this section reviews and expands on the syntax ideas introduced earlier. In general, Python has a simple, statement-based syntax. However, there are a few properties you need to know about: • Statements execute one after another, until you say otherwise. Python nor- mally runs statements in a file or nested block in order from first to last as a sequence, but statements like if (as well as loops and exceptions) cause the inter- preter to jump around in your code. Because Python’s path through a program is called the control flow, statements such as if that affect it are often called control- flow statements. • Block and statement boundaries are detected automatically. As we’ve seen, there are no braces or “begin/end” delimiters around blocks of code in Python; instead, Python uses the indentation of statements under a header to group the statements in a nested block. Similarly, Python statements are not normally ter- minated with semicolons; rather, the end of a line usually marks the end of the statement coded on that line. As a special case, statements can span lines and be combined on a line with special syntax. • Compound statements = header + “:” + indented statements. All Python com- pound statements—those with nested statements—follow the same pattern: a header line terminated with a colon, followed by one or more nested statements, usually indented under the header. The indented statements are called a block (or sometimes, a suite). In the if statement, the elif and else clauses are part of the if, but they are also header lines with nested blocks of their own. As a special case, blocks can show up on the same line as the header if they are simple noncompound code. • Blank lines, spaces, and comments are usually ignored. Blank lines are both optional and ignored in files (but not at the interactive prompt, when they termi- nate compound statements). Spaces inside statements and expressions are almost always ignored (except in string literals, and when used for indentation). Com- ments are always ignored: they start with a # character (not inside a string literal) and extend to the end of the current line. • Docstrings are ignored but are saved and displayed by tools. Python supports an additional comment form called documentation strings (docstrings for short), which, unlike # comments, are retained at runtime for inspection. Docstrings are simplystringsthatshowupatthetopofprogram filesandsomestatements.Python ignores their contents, but they are automatically attached to objects at runtime and may be displayed with documentation tools like PyDoc. Docstrings are part of Python’s larger documentation strategy and are covered in the last chapter in this part of the book. Python Syntax Revisited | 375
- 428. As you’ve seen, there are no variable type declarations in Python; this fact alone makes for a much simpler language syntax than what you may be used to. However, for most new users the lack of the braces and semicolons used to mark blocks and statements in many other languages seems to be the most novel syntactic feature of Python, so let’s explore what this means in more detail. Block Delimiters: Indentation Rules As introduced in Chapter 10, Python detects block boundaries automatically, by line indentation—that is, the empty space to the left of your code. All statements indented the same distance to the right belong to the same block of code. In other words, the statements within a block line up vertically, as in a column. The block ends when the end of the file or a lesser-indented line is encountered, and more deeply nested blocks are simply indented further to the right than the statements in the enclosing block. Compoundstatementbodiescanappearontheheader’slineinsomecaseswe’llexplore later, but most are indented under it. For instance, Figure 12-1 demonstrates the block structure of the following code: x = 1 if x: y = 2 if y: print('block2') print('block1') print('block0') This code contains three blocks: the first (the top-level code of the file) is not indented at all, the second (within the outer if statement) is indented four spaces, and the third (the print statement under the nested if) is indented eight spaces. Figure 12-1. Nested blocks of code: a nested block starts with a statement indented further to the right and ends with either a statement that is indented less, or the end of the file. 376 | Chapter 12: if Tests and Syntax Rules
- 429. In general, top-level (unnested) code must start in column 1. Nested blocks can start in any column; indentation may consist of any number of spaces and tabs, as long as it’s the same for all the statements in a given single block. That is, Python doesn’t care how you indent your code; it only cares that it’s done consistently. Four spaces or one tab per indentation level are common conventions, but there is no absolute standard in the Python world. Indenting code is quite natural in practice. For example, the following (arguably silly) code snippet demonstrates common indentation errors in Python code: x = 'SPAM' # Error: first line indented if 'rubbery' in 'shrubbery': print(x * 8) x += 'NI' # Error: unexpected indentation if x.endswith('NI'): x *= 2 print(x) # Error: inconsistent indentation The properly indented version of this code looks like the following—even for an arti- ficial example like this, proper indentation makes the code’s intent much more appa- rent: x = 'SPAM' if 'rubbery' in 'shrubbery': print(x * 8) # Prints 8 "SPAM" x += 'NI' if x.endswith('NI'): x *= 2 print(x) # Prints "SPAMNISPAMNI" It’s important to know that the only major place in Python where whitespace matters is where it’s used to the left of your code, for indentation; in most other contexts, space can be coded or not. However, indentation is really part of Python syntax, not just a stylistic suggestion: all the statements within any given single block must be indented to the same level, or Python reports a syntax error. This is intentional—because you don’t need to explicitly mark the start and end of a nested block of code, some of the syntactic clutter found in other languages is unnecessary in Python. As described in Chapter 10, making indentation part of the syntax model also enforces consistency, a crucial component of readability in structured programming languages like Python. Python’s syntax is sometimes described as “what you see is what you get” —the indentation of each line of code unambiguously tells readers what it is associated with. This uniform and consistent appearance makes Python code easier to maintain and reuse. Indentation is simpler in practice than its details might initially imply, and it makes your code reflect its logical structure. Consistently indented code always satisfies Python’s rules. Moreover, most text editors (including IDLE) make it easy to follow Python’s indentation model by automatically indenting code as you type it. Python Syntax Revisited | 377
- 430. Avoid mixing tabs and spaces: New error checking in 3.X One rule of thumb: although you can use spaces or tabs to indent, it’s usually not a good idea to mix the two within a block—use one or the other. Technically, tabs count for enough spaces to move the current column number up to a multiple of 8, and your code will work if you mix tabs and spaces consistently. However, such code can be difficult to change. Worse, mixing tabs and spaces makes your code difficult to read completely apart from Python’s syntax rules—tabs may look very different in the next programmer’s editor than they do in yours. In fact, Python 3.X issues an error, for these very reasons, when a script mixes tabs and spaces for indentation inconsistently within a block (that is, in a way that makes it dependent on a tab’s equivalent in spaces). Python 2.X allows such scripts to run, but it has a -t command-line flag that will warn you about inconsistent tab usage and a -tt flag that will issue errors for such code (you can use these switches in a command line like python –t main.py in a system shell window). Python 3.X’s error case is equiv- alent to 2.X’s -tt switch. Statement Delimiters: Lines and Continuations A statement in Python normally ends at the end of the line on which it appears. When a statement is too long to fit on a single line, though, a few special rules may be used to make it span multiple lines: • Statements may span multiple lines if you’re continuing an open syntactic pair. Python lets you continue typing a statement on the next line if you’re coding something enclosed in a (), {}, or [] pair. For instance, expressions in parentheses and dictionary and list literals can span any number of lines; your statement doesn’t end until the Python interpreter reaches the line on which you type the closing part of the pair (a ), }, or ]). Continuation lines—lines 2 and beyond of the statement —can start at any indentation level you like, but you should try to make them align vertically for readability if possible. This open pairs rule also covers set and dic- tionary comprehensions in Python 3.X and 2.7. • Statements may span multiple lines if they end in a backslash. This is a some- what outdated feature that’s not generally recommended, but if a statement needs to span multiple lines, you can also add a backslash (a not embedded in a string literal or comment) at the end of the prior line to indicate you’re continuing on the next line. Because you can also continue by adding parentheses around most con- structs, backslashes are rarely used today. This approach is also error-prone: ac- cidentally forgetting a usually generates a syntax error and might even cause the next line to be silently mistaken (i.e., without warning) for a new statement, with unexpected results. • Special rules for string literals. As we learned in Chapter 7, triple-quoted string blocks are designed to span multiple lines normally. We also learned in Chap- ter 7 that adjacent string literals are implicitly concatenated; when it’s used in 378 | Chapter 12: if Tests and Syntax Rules
- 431. conjunction with the open pairs rule mentioned earlier, wrapping this construct in parentheses allows it to span multiple lines. • Other rules. There are a few other points to mention with regard to statement delimiters. Although it is uncommon, you can terminate a statement with a semi- colon—this convention is sometimes used to squeeze more than one simple (non- compound) statement onto a single line. Also, comments and blank lines can ap- pear anywhere in a file; comments (which begin with a # character) terminate at the end of the line on which they appear. A Few Special Cases Here’s what a continuation line looks like using the open syntactic pairs rule just de- scribed. Delimited constructs, such as lists in square brackets, can span across any number of lines: L = ["Good", "Bad", "Ugly"] # Open pairs may span lines This also works for anything in parentheses (expressions, function arguments, function headers, tuples, and generator expressions), as well as anything in curly braces (dic- tionaries and, in 3.X and 2.7, set literals and set and dictionary comprehensions). Some of these are tools we’ll study in later chapters, but this rule naturally covers most con- structs that span lines in practice. If you like using backslashes to continue lines, you can, but it’s not common practice in Python: if a == b and c == d and d == e and f == g: print('olde') # Backslashes allow continuations... Because any expression can be enclosed in parentheses, you can usually use the open pairs technique instead if you need your code to span multiple lines—simply wrap a part of your statement in parentheses: if (a == b and c == d and d == e and e == f): print('new') # But parentheses usually do too, and are obvious In fact, backslashes are generally frowned on by most Python developers, because they’re too easy to not notice and too easy to omit altogether. In the following, x is assigned 10 with the backslash, as intended; if the backslash is accidentally omitted, though, x is assigned 6 instead, and no error is reported (the +4 is a valid expression statement by itself). In a real program with a more complex assignment, this could be the source of a very nasty bug:1 x = 1 + 2 + 3 # Omitting the makes this very different! +4 Python Syntax Revisited | 379
- 432. As another special case, Python allows you to write more than one noncompound statement (i.e., statements without nested statements) on the same line, separated by semicolons. Some coders use this form to save program file real estate, but it usually makes for more readable code if you stick to one statement per line for most of your work: x = 1; y = 2; print(x) # More than one simple statement As we learned in Chapter 7, triple-quoted string literals span lines too. In addition, if two string literals appear next to each other, they are concatenated as if a + had been added between them—when used in conjunction with the open pairs rule, wrapping in parentheses allows this form to span multiple lines. For example, the first of the following inserts newline characters at line breaks and assigns S to 'naaaanbbbb ncccc', and the second implicitly concatenates and assigns S to 'aaaabbbbcccc'; as we also saw in Chapter 7, # comments are ignored in the second form, but included in the string in the first: S = """ aaaa bbbb cccc""" S = ('aaaa' 'bbbb' # Comments here are ignored 'cccc') Finally, Python lets you move a compound statement’s body up to the header line, provided the body contains just simple (noncompound) statements. You’ll most often see this used for simple if statements with a single test and action, as in the interactive loops we coded in Chapter 10: if 1: print('hello') # Simple statement on header line You can combine some of these special cases to write code that is difficult to read, but I don’t recommend it; as a rule of thumb, try to keep each statement on a line of its own, and indent all but the simplest of blocks. Six months down the road, you’ll be happy you did. Truth Values and Boolean Tests The notions of comparison, equality, and truth values were introduced in Chapter 9. Because the if statement is the first statement we’ve looked at that actually uses test 1. Candidly, it was a bit surprising that backslash continuations were not removed in Python 3.0, given the broad scope of its other changes! See the 3.0 changes tables in Appendix C for a list of 3.0 removals; some seem fairly innocuous in comparison with the dangers inherent in backslash continuations. Then again, this book’s goal is Python instruction, not populist outrage, so the best advice I can give is simply: don’t do this. You should generally avoid backslash continuations in new Python code, even if you developed the habit in your C programming days. 380 | Chapter 12: if Tests and Syntax Rules
- 433. results, we’ll expand on some of these ideas here. In particular, Python’s Boolean oper- ators are a bit different from their counterparts in languages like C. In Python: • All objects have an inherent Boolean true or false value. • Any nonzero number or nonempty object is true. • Zero numbers, empty objects, and the special object None are considered false. • Comparisons and equality tests are applied recursively to data structures. • Comparisons and equality tests return True or False (custom versions of 1 and 0). • Boolean and and or operators return a true or false operand object. • Boolean operators stop evaluating (“short circuit”) as soon as a result is known. The if statement takes action on truth values, but Boolean operators are used to com- bine the results of other tests in richer ways to produce new truth values. More formally, there are three Boolean expression operators in Python: X and Y Is true if both X and Y are true X or Y Is true if either X or Y is true not X Is true if X is false (the expression returns True or False) Here, X and Y may be any truth value, or any expression that returns a truth value (e.g., an equality test, range comparison, and so on). Boolean operators are typed out as words in Python (instead of C’s &&, ||, and !). Also, Boolean and and or operators return a true or false object in Python, not the values True or False. Let’s look at a few examples to see how this works: >>> 2 < 3, 3 < 2 # Less than: return True or False (1 or 0) (True, False) Magnitude comparisons such as these return True or False as their truth results, which, as we learned in Chapter 5 and Chapter 9, are really just custom versions of the integers 1 and 0 (they print themselves differently but are otherwise the same). On the other hand, the and and or operators always return an object—either the object on the left side of the operator or the object on the right. If we test their results in if or other statements, they will be as expected (remember, every object is inherently true or false), but we won’t get back a simple True or False. For or tests, Python evaluates the operand objects from left to right and returns the first one that is true. Moreover, Python stops at the first true operand it finds. This is usually called short-circuit evaluation, as determining a result short-circuits (terminates) the rest of the expression as soon as the result is known: >>> 2 or 3, 3 or 2 # Return left operand if true (2, 3) # Else, return right operand (true or false) Truth Values and Boolean Tests | 381
- 434. >>> [] or 3 3 >>> [] or {} {} In the first line of the preceding example, both operands (2 and 3) are true (i.e., are nonzero), so Python always stops and returns the one on the left—it determines the result because true or anything is always true. In the other two tests, the left operand is false (an empty object), so Python simply evaluates and returns the object on the right—which may happen to have either a true or a false value when tested. Python and operations also stop as soon as the result is known; however, in this case Python evaluates the operands from left to right and stops if the left operand is a false object because it determines the result—false and anything is always false: >>> 2 and 3, 3 and 2 # Return left operand if false (3, 2) # Else, return right operand (true or false) >>> [] and {} [] >>> 3 and [] [] Here, both operands are true in the first line, so Python evaluates both sides and returns the object on the right. In the second test, the left operand is false ([]), so Python stops and returns it as the test result. In the last test, the left side is true (3), so Python evaluates and returns the object on the right—which happens to be a false []. The end result of all this is the same as in C and most other languages—you get a value that is logically true or false if tested in anif or while according to the normal definitions of or and and. However, in Python Booleans return either the left or the right object, not a simple integer flag. This behavior of and and or may seem esoteric at first glance, but see this chapter’s sidebar “Why You Will Care: Booleans” on page 384 for examples of how it is some- times used to advantage in coding by Python programmers. The next section also shows a common way to leverage this behavior, and its more mnemonic replacement in recent versions of Python. The if/else Ternary Expression One common role for the prior section’s Boolean operators is to code an expression that runs the same as an if statement. Consider the following statement, which sets A to either Y or Z, based on the truth value of X: if X: A = Y else: A = Z 382 | Chapter 12: if Tests and Syntax Rules
- 435. Sometimes, though, the items involved in such a statement are so simple that it seems like overkill to spread them across four lines. At other times, we may want to nest such a construct in a larger statement instead of assigning its result to a variable. For these reasons (and, frankly, because the C language has a similar tool), Python 2.5 introduced a new expression format that allows us to say the same thing in one expression: A = Y if X else Z This expression has the exact same effect as the preceding four-line if statement, but it’s simpler to code. As in the statement equivalent, Python runs expression Y only if X turns out to be true, and runs expression Z only if X turns out to be false. That is, it short-circuits, just like the Boolean operators described in the prior section, running just Y or Z but not both. Here are some examples of it in action: >>> A = 't' if 'spam' else 'f' # For strings, nonempty means true >>> A 't' >>> A = 't' if '' else 'f' >>> A 'f' Prior to Python 2.5 (and after 2.5, if you insist), the same effect can often be achieved by a careful combination of the and and or operators, because they return either the object on the left side or the object on the right as the preceding section described: A = ((X and Y) or Z) This works, but there is a catch—you have to be able to assume that Y will be Boolean true. If that is the case, the effect is the same: the and runs first and returns Y if X is true; if X if false the and skips Y, and the or simply returns Z. In other words, we get “if X then Y else Z.” This is equivalent to the ternary form: A = Y if X else Z The and/or combination form also seems to require a “moment of great clarity” to understand the first time you see it, and it’s no longer required as of 2.5—use the equivalent and more robust and mnemonic if/else expression when you need this structure, or use a full if statement if the parts are nontrivial. As a side note, using the following expression in Python is similar because the bool function will translate X into the equivalent of integer 1 or 0, which can then be used as offsets to pick true and false values from a list: A = [Z, Y][bool(X)] For example: >>> ['f', 't'][bool('')] 'f' >>> ['f', 't'][bool('spam')] 't' However, this isn’t exactly the same, because Python will not short-circuit—it will al- ways run both Z and Y, regardless of the value of X. Because of such complexities, you’re The if/else Ternary Expression | 383
- 436. better off using the simpler and more easily understood if/else expression as of Python 2.5 and later. Again, though, you should use even that sparingly, and only if its parts are all fairly simple; otherwise, you’re better off coding the full if statement form to make changes easier in the future. Your coworkers will be happy you did. Still, you may see the and/or version in code written prior to 2.5 (and in Python code written by ex–C programmers who haven’t quite let go of their dark coding pasts).2 Why You Will Care: Booleans One common way to use the somewhat unusual behavior of Python Boolean operators is to select from a set of objects with an or. A statement such as this: X = A or B or C or None assigns X to the first nonempty (that is, true) object among A, B, and C, or to None if all of them are empty. This works because the or operator returns one of its two objects, and it turns out to be a fairly common coding paradigm in Python: to select a nonempty object from among a fixed-size set, simply string them together in an or expression. In simpler form, this is also commonly used to designate a default—the following sets X to A if A is true (or nonempty), and to default otherwise: X = A or default It’s also important to understand the short-circuit evaluation of Boolean operators and the if/else, because it may prevent actions from running. Expressions on the right of a Boolean operator, for example, might call functions that perform substantial or im- portant work, or have side effects that won’t happen if the short-circuit rule takes effect: if f1() or f2(): ... Here, if f1 returns a true (or nonempty) value, Python will never run f2. To guarantee that both functions will be run, call them before the or: tmp1, tmp2 = f1(), f2() if tmp1 or tmp2: ... You’ve already seen another application of this behavior in this chapter: because of the way Booleans work, the expression ((A and B) or C) can be used to emulate an if statement—almost (see this chapter’s discussion of this form for details). We met additional Boolean use cases in prior chapters. As we saw in Chapter 9, because all objects are inherently true or false, it’s common and easier in Python to test an object directly (if X:) than to compare it to an empty value (if X != '':). For a string, the two tests are equivalent. As we also saw in Chapter 5, the preset Boolean values True and False are the same as the integers 1 and 0 and are useful for initializing variables 2. In fact, Python’s Y if X else Z has a slightly different order than C’s X ? Y : Z, and uses more readable words. Its differing order was reportedly chosen in response to analysis of common usage patterns in Python code. According to the Python folklore, this order was also chosen in part to discourage ex–C programmers from overusing it! Remember, simple is better than complex, in Python and elsewhere. If you have to work at packing logic into expressions like this, statements are probably your better bet. 384 | Chapter 12: if Tests and Syntax Rules
- 437. (X = False), for loop tests (while True:), and for displaying results at the interactive prompt. Also watch for related discussion in operator overloading in Part VI: when we define new object types with classes, we can specify their Boolean nature with either the __bool__ or __len__ methods (__bool__ is named __nonzero__ in 2.7). The latter of these is tried if the former is absent and designates false by returning a length of zero—an empty object is considered false. Finally, and as a preview, other tools in Python have roles similar to the or chains at the start of this sidebar: the filter call and list comprehensions we’ll meet later can be used to select true values when the set of candidates isn’t known until runtime (though they evaluate all values and return all that are true), and the any and all built-ins can be used to test if any or all items in a collection are true (though they don’t select an item): >>> L = [1, 0, 2, 0, 'spam', '', 'ham', []] >>> list(filter(bool, L)) # Get true values [1, 2, 'spam', 'ham'] >>> [x for x in L if x] # Comprehensions [1, 2, 'spam', 'ham'] >>> any(L), all(L) # Aggregate truth (True, False) As seen in Chapter 9, the bool function here simply returns its argument’s true or false value, as though it were tested in an if. Watch for more on these related tools in Chapter 14, Chapter 19, and Chapter 20. Chapter Summary In this chapter, we studied the Python if statement. Additionally, because this was our first compound and logical statement, we reviewed Python’s general syntax rules and explored the operation of truth values and tests in more depth than we were able to previously. Along the way, we also looked at how to code multiway branching in Python, learned about the if/else expression introduced in Python 2.5, and explored some common ways that Boolean values crop up in code. The next chapter continues our look at procedural statements by expanding on the while and for loops. There, we’ll learn about alternative ways to code loops in Python, some of which may be better than others. Before that, though, here is the usual chapter quiz. Test Your Knowledge: Quiz 1. How might you code a multiway branch in Python? 2. How can you code an if/else statement as an expression in Python? 3. How can you make a single statement span many lines? Test Your Knowledge: Quiz | 385
- 438. 4. What do the words True and False mean? Test Your Knowledge: Answers 1. An if statement with multiple elif clauses is often the most straightforward way to code a multiway branch, though not necessarily the most concise or flexible. Dictionary indexing can often achieve the same result, especially if the dictionary contains callable functions coded with def statements or lambda expressions. 2. In Python 2.5 and later, the expression form Y if X else Z returns Y if X is true, or Z otherwise; it’s the same as a four-line if statement. The and/or combination (((X and Y) or Z)) can work the same way, but it’s more obscure and requires that the Y part be true. 3. Wrap up the statement in an open syntactic pair ((), [], or {}), and it can span as many lines as you like; the statement ends when Python sees the closing (right) half of the pair, and lines 2 and beyond of the statement can begin at any indentation level. Backslash continuations work too, but are broadly discouraged in the Python world. 4. True and False are just custom versions of the integers 1 and 0, respectively: they always stand for Boolean true and false values in Python. They’re available for use in truth tests and variable initialization, and are printed for expression results at the interactive prompt. In all these roles, they serve as a more mnemonic and hence readable alternative to 1 and 0. 386 | Chapter 12: if Tests and Syntax Rules
- 439. CHAPTER 13 while and for Loops This chapter concludes our tour of Python procedural statements by presenting the language’s two main looping constructs—statements that repeat an action over and over. The first of these, the while statement, provides a way to code general loops. The second, the for statement, is designed for stepping through the items in a sequence or other iterable object and running a block of code for each. We’ve seen both of these informally already, but we’ll fill in additional usage details here. While we’re at it, we’ll also study a few less prominent statements used within loops, such as break and continue, and cover some built-ins commonly used with loops, such as range, zip, and map. Although the while and for statements covered here are the primary syntax provided for coding repeated actions, there are additional looping operations and concepts in Python. Because of that, the iteration story is continued in the next chapter, where we’ll explore the related ideas of Python’s iteration protocol (used by the for loop) and list comprehensions (a close cousin to thefor loop). Later chapters explore even more exotic iteration tools such asgenerators, filter, and reduce. For now, though, let’s keep things simple. while Loops Python’s while statement is the most general iteration construct in the language. In simple terms, it repeatedly executes a block of (normally indented) statements as long as a test at the top keeps evaluating to a true value. It is called a “loop” because control keeps looping back to the start of the statement until the test becomes false. When the test becomes false, control passes to the statement that follows the while block. The net effect is that the loop’s body is executed repeatedly while the test at the top is true. If the test is false to begin with, the body never runs and the while statement is skipped. 387
- 440. General Format In its most complex form, the while statement consists of a header line with a test expression, a body of one or more normally indented statements, and an optional else part that is executed if control exits the loop without a break statement being encountered. Python keeps evaluating the test at the top and executing the statements nested in the loop body until the test returns a false value: while test: # Loop test statements # Loop body else: # Optional else statements # Run if didn't exit loop with break Examples To illustrate, let’s look at a few simple while loops in action. The first, which consists of a print statement nested in a while loop, just prints a message forever. Recall that True is just a custom version of the integer 1 and always stands for a Boolean true value; because the test is always true, Python keeps executing the body forever, or until you stop its execution. This sort of behavior is usually called an infinite loop—it’s not really immortal, but you may need a Ctrl-C key combination to forcibly terminate one: >>> while True: ... print('Type Ctrl-C to stop me!') The next example keeps slicing off the first character of a string until the string is empty and hence false. It’s typical to test an object directly like this instead of using the more verbose equivalent (while x != '':). Later in this chapter, we’ll see other ways to step through the items in a string more easily with a for loop. >>> x = 'spam' >>> while x: # While x is not empty ... print(x, end=' ') # In 2.X use print x, ... x = x[1:] # Strip first character off x ... spam pam am m Note the end=' ' keyword argument used here to place all outputs on the same line separated by a space; see Chapter 11 if you’ve forgotten why this works as it does. This may leave your input prompt in an odd state at the end of your output; type Enter to reset. Python 2.X readers: also remember to use a trailing comma instead of end in the prints like this. The following code counts from the value of a up to, but not including, b. We’ll also see an easier way to do this with a Python for loop and the built-in range function later: >>> a=0; b=10 >>> while a < b: # One way to code counter loops ... print(a, end=' ') ... a += 1 # Or, a = a + 1 388 | Chapter 13: while and for Loops
- 441. ... 0 1 2 3 4 5 6 7 8 9 Finally, notice that Python doesn’t have what some languages call a “do until” loop statement. However, we can simulate one with a test and break at the bottom of the loop body, so that the loop’s body is always run at least once: while True: ...loop body... if exitTest(): break To fully understand how this structure works, we need to move on to the next section and learn more about the break statement. break, continue, pass, and the Loop else Now that we’ve seen a few Python loops in action, it’s time to take a look at two simple statements that have a purpose only when nested inside loops—the break and con tinue statements. While we’re looking at oddballs, we will also study the loop else clause here because it is intertwined with break, and Python’s empty placeholder state- ment, pass (which is not tied to loops per se, but falls into the general category of simple one-word statements). In Python: break Jumps out of the closest enclosing loop (past the entire loop statement) continue Jumps to the top of the closest enclosing loop (to the loop’s header line) pass Does nothing at all: it’s an empty statement placeholder Loop else block Runs if and only if the loop is exited normally (i.e., without hitting a break) General Loop Format Factoring in break and continue statements, the general format of the while loop looks like this: while test: statements if test: break # Exit loop now, skip else if present if test: continue # Go to top of loop now, to test1 else: statements # Run if we didn't hit a 'break' break and continue statements can appear anywhere inside the while (or for) loop’s body, but they are usually coded further nested in an if test to take action in response to some condition. break, continue, pass, and the Loop else | 389
- 442. Let’s turn to a few simple examples to see how these statements come together in practice. pass Simple things first: the pass statement is a no-operation placeholder that is used when the syntax requires a statement, but you have nothing useful to say. It is often used to code an empty body for a compound statement. For instance, if you want to code an infinite loop that does nothing each time through, do it with a pass: while True: pass # Type Ctrl-C to stop me! Because the body is just an empty statement, Python gets stuck in this loop. pass is roughly to statements as None is to objects—an explicit nothing. Notice that here the while loop’s body is on the same line as the header, after the colon; as with if state- ments, this only works if the body isn’t a compound statement. This example does nothing forever. It probably isn’t the most useful Python program ever written (unless you want to warm up your laptop computer on a cold winter’s day!);frankly,though,Icouldn’tthinkofabetterpass exampleatthispointinthebook. We’ll see other places where pass makes more sense later—for instance, to ignore ex- ceptions caught by try statements, and to define empty class objects with attributes that behave like “structs” and “records” in other languages. A pass is also sometime coded to mean “to be filled in later,” to stub out the bodies of functions temporarily: def func1(): pass # Add real code here later def func2(): pass We can’t leave the body empty without getting a syntax error, so we say pass instead. Version skew note: Python 3.X (but not 2.X) allows ellipses coded as ... (literally, three consecutive dots) to appear any place an expres- sion can. Because ellipses do nothing by themselves, this can serve as an alternative to the pass statement, especially for code to be filled in later—a sort of Python “TBD”: def func1(): ... # Alternative to pass def func2(): ... func1() # Does nothing if called Ellipses can also appear on the same line as a statement header and may be used to initialize variable names if no specific type is required: def func1(): ... # Works on same line too def func2(): ... 390 | Chapter 13: while and for Loops
- 443. >>> X = ... # Alternative to None >>> X Ellipsis This notation is new in Python 3.X—and goes well beyond the original intent of ... in slicing extensions—so time will tell if it becomes wide- spread enough to challenge pass and None in these roles. continue The continue statement causes an immediate jump to the top of a loop. It also some- times lets you avoid statement nesting. The next example uses continue to skip odd numbers. This code prints all even numbers less than 10 and greater than or equal to 0. Remember, 0 means false and % is the remainder of division (modulus) operator, so this loop counts down to 0, skipping numbers that aren’t multiples of 2—it prints 8 6 4 2 0: x = 10 while x: x = x−1 # Or, x -= 1 if x % 2 != 0: continue # Odd? -- skip print print(x, end=' ') Because continue jumps to the top of the loop, you don’t need to nest the print state- ment here inside an if test; the print is only reached if the continue is not run. If this sounds similar to a “go to” in other languages, it should. Python has no “go to” state- ment, but because continue lets you jump about in a program, many of the warnings about readability and maintainability you may have heard about “go to” apply. con tinue should probably be used sparingly, especially when you’re first getting started with Python. For instance, the last example might be clearer if the print were nested under the if: x = 10 while x: x = x−1 if x % 2 == 0: # Even? -- print print(x, end=' ') Later in this book, we’ll also learn that raised and caught exceptions can also emulate “goto”statementsinlimitedandstructuredways;staytunedformoreonthistechnique in Chapter 36 where we will learn how to use it to break out of multiple nested loops, a feat not possible with the next section’s topic alone. break The break statement causes an immediate exit from a loop. Because the code that fol- lows it in the loop is not executed if the break is reached, you can also sometimes avoid nesting by including a break. For example, here is a simple interactive loop (a variant break, continue, pass, and the Loop else | 391
- 444. of a larger example we studied in Chapter 10) that inputs data with input (known as raw_input in Python 2.X) and exits when the user enters “stop” for the name request: >>> while True: ... name = input('Enter name:') # Use raw_input() in 2.X ... if name == 'stop': break ... age = input('Enter age: ') ... print('Hello', name, '=>', int(age) ** 2) ... Enter name:bob Enter age: 40 Hello bob => 1600 Enter name:sue Enter age: 30 Hello sue => 900 Enter name:stop Notice how this code converts the age input to an integer with int before raising it to the second power; as you’ll recall, this is necessary because input returns user input as a string. In Chapter 36, you’ll see that input also raises an exception at end-of-file (e.g., if the user types Ctrl-Z on Windows or Ctrl-D on Unix); if this matters, wrap input in try statements. Loop else When combined with the loop else clause, the break statement can often eliminate the need for the search status flags used in other languages. For instance, the following piece of code determines whether a positive integer y is prime by searching for factors greater than 1: x = y // 2 # For some y > 1 while x > 1: if y % x == 0: # Remainder print(y, 'has factor', x) break # Skip else x -= 1 else: # Normal exit print(y, 'is prime') Rather than setting a flag to be tested when the loop is exited, it inserts a break where a factor is found. This way, the loop else clause can assume that it will be executed only if no factor is found; if you don’t hit the break, the number is prime. Trace through this code to see how this works. The loop else clause is also run if the body of the loop is never executed, as you don’t run a break in that event either; in a while loop, this happens if the test in the header isfalsetobeginwith.Thus,in theprecedingexample youstillgetthe“isprime”message if x is initially less than or equal to 1 (for instance, if y is 2). 392 | Chapter 13: while and for Loops
- 445. This example determines primes, but only informally so. Numbers less than 2 are not considered prime by the strict mathematical definition. To be really picky, this code also fails for negative numbers and succeeds for floating-point numbers with no decimal digits. Also note that its code must use // instead of / in Python 3.X because of the migration of / to “true division,” as described in Chapter 5 (we need the initial division to truncate remainders, not retain them!). If you want to ex- periment with this code, be sure to see the exercise at the end of Part IV, which wraps it in a function for reuse. More on the loop else Because the loop else clause is unique to Python, it tends to perplex some newcomers (and go unused by some veterans; I’ve met some who didn’t even know there was an else on loops!). In general terms, the loop else simply provides explicit syntax for a common coding scenario—it is a coding structure that lets us catch the “other” way out of a loop, without setting and checking flags or conditions. Suppose, for instance, that we are writing a loop to search a list for a value, and we need to know whether the value was found after we exit the loop. We might code such a task this way (this code is intentionally abstract and incomplete; x is a sequence and match is a tester function to be defined): found = False while x and not found: if match(x[0]): # Value at front? print('Ni') found = True else: x = x[1:] # Slice off front and repeat if not found: print('not found') Here, we initialize, set, and later test a flag to determine whether the search succeeded or not. This is valid Python code, and it does work; however, this is exactly the sort of structure that the loop else clause is there to handle. Here’s an else equivalent: while x: # Exit when x empty if match(x[0]): print('Ni') break # Exit, go around else x = x[1:] else: print('Not found') # Only here if exhausted x This version is more concise. The flag is gone, and we’ve replaced the if test at the loop end with an else (lined up vertically with the word while). Because the break inside the main part of the while exits the loop and goes around the else, this serves as a more structured way to catch the search-failure case. break, continue, pass, and the Loop else | 393
- 446. Some readers might have noticed that the prior example’s else clause could be replaced with a test for an empty x after the loop (e.g., if not x:). Although that’s true in this example, the else provides explicit syntax for this coding pattern (it’s more obviously a search-failure clause here), and such an explicit empty test may not apply in some cases. The loop else becomes even more useful when used in conjunction with the for loop—the topic of the next section—because sequence iteration is not under your control. Why You Will Care: Emulating C while Loops The section on expression statements in Chapter 11 stated that Python doesn’t allow statements such as assignments to appear in places where it expects an expression. That is, each statement must generally appear on a line by itself, not nested in a larger con- struct. That means this common C language coding pattern won’t work in Python: while ((x = next(obj)) != NULL) {...process x...} C assignments return the value assigned, but Python assignments are just statements, not expressions. This eliminates a notorious class of C errors: you can’t accidentally type = in Python when you mean ==. If you need similar behavior, though, there are at least three ways to get the same effect in Python while loops without embedding as- signments in loop tests. You can move the assignment into the loop body with a break: while True: x = next(obj) if not x: break ...process x... or move the assignment into the loop with tests: x = True while x: x = next(obj) if x: ...process x... or move the first assignment outside the loop: x = next(obj) while x: ...process x... x = next(obj) Of these three coding patterns, the first may be considered by some to be the least structured, but it also seems to be the simplest and is the most commonly used. A simple Python for loop may replace such C loops as well and be more Pythonic, but C doesn’t have a directly analogous tool: for x in obj: ...process x... 394 | Chapter 13: while and for Loops
- 447. for Loops The for loop is a generic iterator in Python: it can step through the items in any ordered sequence or other iterable object. The for statement works on strings, lists, tuples, and other built-in iterables, as well as new user-defined objects that we’ll learn how to create later with classes. We met for briefly in Chapter 4 and in conjunction with sequence object types; let’s expand on its usage more formally here. General Format The Python for loop begins with a header line that specifies an assignment target (or targets), along with the object you want to step through. The header is followed by a block of (normally indented) statements that you want to repeat: for target in object: # Assign object items to target statements # Repeated loop body: use target else: # Optional else part statements # If we didn't hit a 'break' When Python runs a for loop, it assigns the items in the iterable object to the target one by one and executes the loop body for each. The loop body typically uses the assignment target to refer to the current item in the sequence as though it were a cursor stepping through the sequence. The name used as the assignment target in a for header line is usually a (possibly new) variable in the scope where the for statement is coded. There’s not much unique about this name; it can even be changed inside the loop’s body, but it will automatically be set to the next item in the sequence when control returns to the top of the loop again. After the loop this variable normally still refers to the last item visited, which is the last item in the sequence unless the loop exits with a break statement. The for statement also supports an optional else block, which works exactly as it does in a while loop—it’s executed if the loop exits without running into a break statement (i.e., if all items in the sequence have been visited). The break and continue statements introduced earlier also work the same in a for loop as they do in a while. The for loop’s complete format can be described this way: for target in object: # Assign object items to target statements if test: break # Exit loop now, skip else if test: continue # Go to top of loop now else: statements # If we didn't hit a 'break' Examples Let’stypeafewfor loopsinteractivelynow,soyoucanseehowtheyareusedinpractice. for Loops | 395
- 448. Basic usage As mentioned earlier, a for loop can step across any kind of sequence object. In our first example, for instance, we’ll assign the name x to each of the three items in a list in turn, from left to right, and the print statement will be executed for each. Inside the print statement (the loop body), the name x refers to the current item in the list: >>> for x in ["spam", "eggs", "ham"]: ... print(x, end=' ') ... spam eggs ham The next two examples compute the sum and product of all the items in a list. Later in this chapter and later in the book we’ll meet tools that apply operations such as + and * to items in a list automatically, but it’s often just as easy to use a for: >>> sum = 0 >>> for x in [1, 2, 3, 4]: ... sum = sum + x ... >>> sum 10 >>> prod = 1 >>> for item in [1, 2, 3, 4]: prod *= item ... >>> prod 24 Other data types Any sequence works in a for, as it’s a generic tool. For example, for loops work on strings and tuples: >>> S = "lumberjack" >>> T = ("and", "I'm", "okay") >>> for x in S: print(x, end=' ') # Iterate over a string ... l u m b e r j a c k >>> for x in T: print(x, end=' ') # Iterate over a tuple ... and I'm okay In fact, as we’ll learn in the next chapter when we explore the notion of “iterables,” for loops can even work on some objects that are not sequences—files and dictionaries work, too. Tuple assignment in for loops If you’re iterating through a sequence of tuples, the loop target itself can actually be a tuple of targets. This is just another case of the tuple-unpacking assignment we studied 396 | Chapter 13: while and for Loops
- 449. in Chapter 11 at work. Remember, the for loop assigns items in the sequence object to the target, and assignment works the same everywhere: >>> T = [(1, 2), (3, 4), (5, 6)] >>> for (a, b) in T: # Tuple assignment at work ... print(a, b) ... 1 2 3 4 5 6 Here, the first time through the loop is like writing (a,b) = (1,2), the second time is like writing (a,b) = (3,4), and so on. The net effect is to automatically unpack the current tuple on each iteration. This form is commonly used in conjunction with the zip call we’ll meet later in this chapter to implement parallel traversals. It also makes regular appearances in conjunc- tion with SQL databases in Python, where query result tables are returned as sequences of sequences like the list used here—the outer list is the database table, the nested tuples are the rows within the table, and tuple assignment extracts columns. Tuples in for loops also come in handy to iterate through both keys and values in dictionaries using the items method, rather than looping through the keys and indexing to fetch the values manually: >>> D = {'a': 1, 'b': 2, 'c': 3} >>> for key in D: ... print(key, '=>', D[key]) # Use dict keys iterator and index ... a => 1 c => 3 b => 2 >>> list(D.items()) [('a', 1), ('c', 3), ('b', 2)] >>> for (key, value) in D.items(): ... print(key, '=>', value) # Iterate over both keys and values ... a => 1 c => 3 b => 2 It’s important to note that tuple assignment in for loops isn’t a special case; any as- signment target works syntactically after the word for. We can always assign manually within the loop to unpack: >>> T [(1, 2), (3, 4), (5, 6)] >>> for both in T: ... a, b = both # Manual assignment equivalent ... print(a, b) # 2.X: prints with enclosing tuple "()" ... for Loops | 397
- 450. 1 2 3 4 5 6 But tuples in the loop header save us an extra step when iterating through sequences of sequences. As suggested in Chapter 11, even nested structures may be automatically unpacked this way in a for: >>> ((a, b), c) = ((1, 2), 3) # Nested sequences work too >>> a, b, c (1, 2, 3) >>> for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: print(a, b, c) ... 1 2 3 4 5 6 Even this is not a special case, though—the for loop simply runs the sort of assignment we ran just before it, on each iteration. Any nested sequence structure may be unpacked this way, simply because sequence assignment is so generic: >>> for ((a, b), c) in [([1, 2], 3), ['XY', 6]]: print(a, b, c) ... 1 2 3 X Y 6 Python 3.X extended sequence assignment in for loops In fact, because the loop variable in a for loop can be any assignment target, we can also use Python 3.X’s extended sequence-unpacking assignment syntax here to extract items and sections of sequences within sequences. Really, this isn’t a special case either, but simply a new assignment form in 3.X, as discussed in Chapter 11; because it works in assignment statements, it automatically works in for loops. Consider the tuple assignment form introduced in the prior section. A tuple of values is assigned to a tuple of names on each iteration, exactly like a simple assignment state- ment: >>> a, b, c = (1, 2, 3) # Tuple assignment >>> a, b, c (1, 2, 3) >>> for (a, b, c) in [(1, 2, 3), (4, 5, 6)]: # Used in for loop ... print(a, b, c) ... 1 2 3 4 5 6 In Python 3.X, because a sequence can be assigned to a more general set of names with a starred name to collect multiple items, we can use the same syntax to extract parts of nested sequences in the for loop: >>> a, *b, c = (1, 2, 3, 4) # Extended seq assignment >>> a, b, c 398 | Chapter 13: while and for Loops
- 451. (1, [2, 3], 4) >>> for (a, *b, c) in [(1, 2, 3, 4), (5, 6, 7, 8)]: ... print(a, b, c) ... 1 [2, 3] 4 5 [6, 7] 8 In practice, this approach might be used to pick out multiple columns from rows of data represented as nested sequences. In Python 2.X starred names aren’t allowed, but you can achieve similar effects by slicing. The only difference is that slicing returns a type-specific result, whereas starred names always are assigned lists: >>> for all in [(1, 2, 3, 4), (5, 6, 7, 8)]: # Manual slicing in 2.X ... a, b, c = all[0], all[1:3], all[3] ... print(a, b, c) ... 1 (2, 3) 4 5 (6, 7) 8 See Chapter 11 for more on this assignment form. Nested for loops Now let’s look at a for loop that’s a bit more sophisticated than those we’ve seen so far. The next example illustrates statement nesting and the loop else clause in a for. Given a list of objects (items) and a list of keys (tests), this code searches for each key in the objects list and reports on the search’s outcome: >>> items = ["aaa", 111, (4, 5), 2.01] # A set of objects >>> tests = [(4, 5), 3.14] # Keys to search for >>> >>> for key in tests: # For all keys ... for item in items: # For all items ... if item == key: # Check for match ... print(key, "was found") ... break ... else: ... print(key, "not found!") ... (4, 5) was found 3.14 not found! Because the nested if runs a break when a match is found, the loop else clause can assume that if it is reached, the search has failed. Notice the nesting here. When this code runs, there are two loops going at the same time: the outer loop scans the keys list, and the inner loop scans the items list for each key. The nesting of the loop else clause is critical; it’s indented to the same level as the header line of the inner for loop, so it’s associated with the inner loop, not the if or the outer for. This example is illustrative, but it may be easier to code if we employ the in operator to test membership. Because in implicitly scans an object looking for a match (at least logically), it replaces the inner loop: for Loops | 399
- 452. >>> for key in tests: # For all keys ... if key in items: # Let Python check for a match ... print(key, "was found") ... else: ... print(key, "not found!") ... (4, 5) was found 3.14 not found! In general, it’s a good idea to let Python do as much of the work as possible (as in this solution) for the sake of brevity and performance. The next example is similar, but builds a list as it goes for later use instead of printing. It performs a typical data-structure task with a for—collecting common items in two sequences (strings)—and serves as a rough set intersection routine. After the loop runs, res refers to a list that contains all the items found in seq1 and seq2: >>> seq1 = "spam" >>> seq2 = "scam" >>> >>> res = [] # Start empty >>> for x in seq1: # Scan first sequence ... if x in seq2: # Common item? ... res.append(x) # Add to result end ... >>> res ['s', 'a', 'm'] Unfortunately, this code is equipped to work only on two specific variables: seq1 and seq2. It would be nice if this loop could somehow be generalized into a tool you could use more than once. As you’ll see, that simple idea leads us to functions, the topic of the next part of the book. This code also exhibits the classic list comprehension pattern—collecting a results list with an iteration and optional filter test—and could be coded more concisely too: >>> [x for x in seq1 if x in seq2] # Let Python collect results ['s', 'a', 'm'] But you’ll have to read on to the next chapter for the rest of this story. Why You Will Care: File Scanners In general, loops come in handy anywhere you need to repeat an operation or process something more than once. Because files contain multiple characters and lines, they are one of the more typical use cases for loops. To load a file’s contents into a string all at once, you simply call the file object’s read method: file = open('test.txt', 'r') # Read contents into a string print(file.read()) But to load a file in smaller pieces, it’s common to code either a while loop with breaks on end-of-file, or a for loop. To read by characters, either of the following codings will suffice: 400 | Chapter 13: while and for Loops
- 453. file = open('test.txt') while True: char = file.read(1) # Read by character if not char: break # Empty string means end-of-file print(char) for char in open('test.txt').read(): print(char) The for loop here also processes each character, but it loads the file into memory all at once (and assumes it fits!). To read by lines or blocks instead, you can use while loop code like this: file = open('test.txt') while True: line = file.readline() # Read line by line if not line: break print(line.rstrip()) # Line already has a n file = open('test.txt', 'rb') while True: chunk = file.read(10) # Read byte chunks: up to 10 bytes if not chunk: break print(chunk) You typically read binary data in blocks. To read text files line by line, though, the for loop tends to be easiest to code and the quickest to run: for line in open('test.txt').readlines(): print(line.rstrip()) for line in open('test.txt'): # Use iterators: best for text input print(line.rstrip()) Both of these versions work in both Python 2.X and 3.X. The first uses the file read lines method to load a file all at once into a line-string list, and the last example here relies on file iterators to automatically read one line on each loop iteration. The last example is also generally the best option for text files—besides its simplicity, it works for arbitrarily large files because it doesn’t load the entire file into memory all at once. The iterator version may also be the quickest, though I/O performance may vary per Python line and release. File readlines calls can still be useful, though—to reverse a file’s lines, for example, assuming its content can fit in memory. The reversed built-in accepts a sequence, but not an arbitrary iterable that generates values; in other words, a list works, but a file object doesn’t: for line in reversed(open('test.txt').readlines()): ... In some 2.X Python code, you may also see the name open replaced with file and the file object’s older xreadlines method used to achieve the same effect as the file’s auto- matic line iterator (it’s like readlines but doesn’t load the file into memory all at once). Both file and xreadlines are removed in Python 3.X, because they are redundant. You should generally avoid them in new 2.X code too—use file iterators and open call in recent 2.X releases—but they may pop up in older code and resources. for Loops | 401
- 454. See the library manual for more on the calls used here, and Chapter 14 for more on file line iterators. Also watch for the sidebar “Why You Will Care: Shell Commands and More” on page 411 in this chapter; it applies these same file tools to the os.popen command-line launcher to read program output. There’s more on reading files in Chapter 37 too; as we’ll see there, text and binary files have slightly different semantics in 3.X. Loop Coding Techniques The for loop we just studied subsumes most counter-style loops. It’s generally simpler to code and often quicker to run than a while, so it’s the first tool you should reach for whenever you need to step through a sequence or other iterable. In fact, as a general rule, you should resist the temptation to count things in Python—its iteration tools au- tomate much of the work you do to loop over collections in lower-level languages like C. Still, there are situations where you will need to iterate in more specialized ways. For example, what if you need to visit every second or third item in a list, or change the list along the way? How about traversing more than one sequence in parallel, in the same for loop? What if you need indexes too? You can always code such unique iterations with a while loop and manual indexing, but Python provides a set of built-ins that allow you to specialize the iteration in a for: • The built-in range function (available since Python 0.X) produces a series of suc- cessively higher integers, which can be used as indexes in a for. • The built-in zip function (available since Python 2.0) returns a series of parallel- item tuples, which can be used to traverse multiple sequences in a for. • The built-in enumerate function (available since Python 2.3) generates both the values and indexes of items in an iterable, so we don’t need to count manually. • The built-in map function (available since Python 1.0) can have a similar effect to zip in Python 2.X, though this role is removed in 3.X. Because for loops may run quicker than while-based counter loops, though, it’s to your advantage to use tools like these that allow you to use for whenever possible. Let’s look at each of these built-ins in turn, in the context of common use cases. As we’ll see, their usage may differ slightly between 2.X and 3.X, and some of their applications are more valid than others. Counter Loops: range Our first loop-related function, range, is really a general tool that can be used in a variety of contexts. We met it briefly in Chapter 4. Although it’s used most often to generate indexes in a for, you can use it anywhere you need a series of integers. In 402 | Chapter 13: while and for Loops
- 455. Python 2.X range creates a physical list; in 3.X, range is an iterable that generates items on demand, so we need to wrap it in a list call to display its results all at once in 3.X only: >>> list(range(5)), list(range(2, 5)), list(range(0, 10, 2)) ([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8]) With one argument, range generates a list of integers from zero up to but not including the argument’s value. If you pass in two arguments, the first is taken as the lower bound. An optional third argument can give a step; if it is used, Python adds the step to each successive integer in the result (the step defaults to +1). Ranges can also be nonpositive and nonascending, if you want them to be: >>> list(range(−5, 5)) [−5, −4, −3, −2, −1, 0, 1, 2, 3, 4] >>> list(range(5, −5, −1)) [5, 4, 3, 2, 1, 0, −1, −2, −3, −4] We’ll get more formal about iterables like this one in Chapter 14. There, we’ll also see that Python 2.X has a cousin named xrange, which is like its range but doesn’t build the result list in memory all at once. This is a space optimization, which is subsumed in 3.X by the generator behavior of its range. Although such range results may be useful all by themselves, they tend to come in most handy within for loops. For one thing, they provide a simple way to repeat an action a specific number of times. To print three lines, for example, use a range to generate the appropriate number of integers: >>> for i in range(3): ... print(i, 'Pythons') ... 0 Pythons 1 Pythons 2 Pythons Note that for loops force results from range automatically in 3.X, so we don’t need to use a list wrapper here in 3.X (in 2.X we get a temporary list unless we call xrange instead). Sequence Scans: while and range Versus for The range call is also sometimes used to iterate over a sequence indirectly, though it’s often not the best approach in this role. The easiest and generally fastest way to step through a sequence exhaustively is always with a simple for, as Python handles most of the details for you: >>> X = 'spam' >>> for item in X: print(item, end=' ') # Simple iteration ... s p a m Loop Coding Techniques | 403
- 456. Internally, the for loop handles the details of the iteration automatically when used this way. If you really need to take over the indexing logic explicitly, you can do it with a while loop: >>> i = 0 >>> while i < len(X): # while loop iteration ... print(X[i], end=' ') ... i += 1 ... s p a m You can also do manual indexing with a for, though, if you use range to generate a list of indexes to iterate through. It’s a multistep process, but it’s sufficient to generate offsets, rather than the items at those offsets: >>> X 'spam' >>> len(X) # Length of string 4 >>> list(range(len(X))) # All legal offsets into X [0, 1, 2, 3] >>> >>> for i in range(len(X)): print(X[i], end=' ') # Manual range/len iteration ... s p a m Note that because this example is stepping over a list of offsets into X, not the actual items of X, we need to index back into X within the loop to fetch each item. If this seems like overkill, though, it’s because it is: there’s really no reason to work this hard in this example. Although the range/len combination suffices in this role, it’s probably not the best option. It may run slower, and it’s also more work than we need to do. Unless you have a special indexing requirement, you’re better off using the simple for loop form in Python: >>> for item in X: print(item, end=' ') # Use simple iteration if you can As a general rule, use for instead of while whenever possible, and don’t use range calls in for loops except as a last resort. This simpler solution is almost always better. Like every good rule, though, there are plenty of exceptions—as the next section demon- strates. Sequence Shufflers: range and len Though not ideal for simple sequence scans, the coding pattern used in the prior ex- ample does allow us to do more specialized sorts of traversals when required. For ex- ample, some algorithms can make use of sequence reordering—to generate alternatives in searches, to test the effect of different value orderings, and so on. Such cases may require offsets in order to pull sequences apart and put them back together, as in the 404 | Chapter 13: while and for Loops
- 457. following; the range’s integers provide a repeat count in the first, and a position for slicing in the second: >>> S = 'spam' >>> for i in range(len(S)): # For repeat counts 0..3 ... S = S[1:] + S[:1] # Move front item to end ... print(S, end=' ') ... pams amsp mspa spam >>> S 'spam' >>> for i in range(len(S)): # For positions 0..3 ... X = S[i:] + S[:i] # Rear part + front part ... print(X, end=' ') ... spam pams amsp mspa Trace through these one iteration at a time if they seem confusing. The second creates the same results as the first, though in a different order, and doesn’t change the original variable as it goes. Because both slice to obtain parts to concatenate, they also work on any type of sequence, and return sequences of the same type as that being shuffled— if you shuffle a list, you create reordered lists: >>> L = [1, 2, 3] >>> for i in range(len(L)): ... X = L[i:] + L[:i] # Works on any sequence type ... print(X, end=' ') ... [1, 2, 3] [2, 3, 1] [3, 1, 2] We’ll make use of code like this to test functions with different argument orderings in Chapter 18, and will extend it to functions, generators, and more complete permuta- tions in Chapter 20—it’s a widely useful tool. Nonexhaustive Traversals: range Versus Slices Cases like that of the prior section are valid applications for the range/len combination. We might also use this technique to skip items as we go: >>> S = 'abcdefghijk' >>> list(range(0, len(S), 2)) [0, 2, 4, 6, 8, 10] >>> for i in range(0, len(S), 2): print(S[i], end=' ') ... a c e g i k Here, we visit every second item in the string S by stepping over the generated range list. To visit every third item, change the third range argument to be 3, and so on. In effect, using range this way lets you skip items in loops while still retaining the simplicity of the for loop construct. Loop Coding Techniques | 405
- 458. In most cases, though, this is also probably not the “best practice” technique in Python today. If you really mean to skip items in a sequence, the extended three-limit form of the slice expression, presented in Chapter 7, provides a simpler route to the same goal. To visit every second character in S, for example, slice with a stride of 2: >>> S = 'abcdefghijk' >>> for c in S[::2]: print(c, end=' ') ... a c e g i k The result is the same, but substantially easier for you to write and for others to read. The potential advantage to using range here instead is space: slicing makes a copy of the string in both 2.X and 3.X, while range in 3.X and xrange in 2.X do not create a list; for very large strings, they may save memory. Changing Lists: range Versus Comprehensions Another common place where you may use the range/len combination with for is in loops that change a list as it is being traversed. Suppose, for example, that you need to add 1 to every item in a list (maybe you’re giving everyone a raise in an employee database list). You can try this with a simple for loop, but the result probably won’t be exactly what you want: >>> L = [1, 2, 3, 4, 5] >>> for x in L: ... x += 1 # Changes x, not L ... >>> L [1, 2, 3, 4, 5] >>> x 6 This doesn’t quite work—it changes the loop variable x, not the list L. The reason is somewhat subtle. Each time through the loop, x refers to the next integer already pulled out of the list. In the first iteration, for example, x is integer 1. In the next iteration, the loop body sets x to a different object, integer 2, but it does not update the list where 1 originally came from; it’s a piece of memory separate from the list. To really change the list as we march across it, we need to use indexes so we can assign an updated value to each position as we go. The range/len combination can produce the required indexes for us: >>> L = [1, 2, 3, 4, 5] >>> for i in range(len(L)): # Add one to each item in L ... L[i] += 1 # Or L[i] = L[i] + 1 ... >>> L [2, 3, 4, 5, 6] 406 | Chapter 13: while and for Loops
- 459. When coded this way, the list is changed as we proceed through the loop. There is no way to do the same with a simple for x in L:–style loop, because such a loop iterates through actual items, not list positions. But what about the equivalent while loop? Such a loop requires a bit more work on our part, and might run more slowly depending on your Python (it does on 2.7 and 3.3, though less so on 3.3—we’ll see how to verify this in Chapter 21): >>> i = 0 >>> while i < len(L): ... L[i] += 1 ... i += 1 ... >>> L [3, 4, 5, 6, 7] Here again, though, the range solution may not be ideal either. A list comprehension expression of the form: [x + 1 for x in L] likely runs faster today and would do similar work, albeit without changing the original list in place (we could assign the expression’s new list object result back to L, but this would not update any other references to the original list). Because this is such a central looping concept, we’ll save a complete exploration of list comprehensions for the next chapter, and continue this story there. Parallel Traversals: zip and map Our next loop coding technique extends a loop’s scope. As we’ve seen, the range built- in allows us to traverse sequences with for in a nonexhaustive fashion. In the same spirit, the built-in zip function allows us to use for loops to visit multiple sequences in parallel—not overlapping in time, but during the same loop. In basic operation, zip takes one or more sequences as arguments and returns a series of tuples that pair up parallel items taken from those sequences. For example, suppose we’re working with two lists (a list of names and addresses paired by position, perhaps): >>> L1 = [1,2,3,4] >>> L2 = [5,6,7,8] To combine the items in these lists, we can use zip to create a list of tuple pairs. Like range, zip is a list in Python 2.X, but an iterable object in 3.X where we must wrap it in a list call to display all its results at once (again, there’s more on iterables coming up in the next chapter): >>> zip(L1, L2) <zip object at 0x026523C8> >>> list(zip(L1, L2)) # list() required in 3.X, not 2.X [(1, 5), (2, 6), (3, 7), (4, 8)] Such a result may be useful in other contexts as well, but when wedded with the for loop, it supports parallel iterations: Loop Coding Techniques | 407
- 460. >>> for (x, y) in zip(L1, L2): ... print(x, y, '--', x+y) ... 1 5 -- 6 2 6 -- 8 3 7 -- 10 4 8 -- 12 Here, we step over the result of the zip call—that is, the pairs of items pulled from the two lists. Notice that this for loop again uses the tuple assignment form we met earlier to unpack each tuple in the zip result. The first time through, it’s as though we ran the assignment statement (x, y) = (1, 5). The net effect is that we scan both L1 and L2 in our loop. We could achieve a similar effect with a while loop that handles indexing manually, but it would require more typing and would likely run more slowly than the for/zip approach. Strictly speaking, the zip function is more general than this example suggests. For in- stance, it accepts any type of sequence (really, any iterable object, including files), and it accepts more than two arguments. With three arguments, as in the following exam- ple, it builds a list of three-item tuples with items from each sequence, essentially pro- jecting by columns (technically, we get an N-ary tuple for N arguments): >>> T1, T2, T3 = (1,2,3), (4,5,6), (7,8,9) >>> T3 (7, 8, 9) >>> list(zip(T1, T2, T3)) # Three tuples for three arguments [(1, 4, 7), (2, 5, 8), (3, 6, 9)] Moreover, zip truncates result tuples at the length of the shortest sequence when the argument lengths differ. In the following, we zip together two strings to pick out char- acters in parallel, but the result has only as many tuples as the length of the shortest sequence: >>> S1 = 'abc' >>> S2 = 'xyz123' >>> >>> list(zip(S1, S2)) # Truncates at len(shortest) [('a', 'x'), ('b', 'y'), ('c', 'z')] map equivalence in Python 2.X In Python 2.X only, the related built-in map function pairs items from sequences in a similar fashion when passed None for its function argument, but it pads shorter se- quences with None if the argument lengths differ instead of truncating to the shortest length: >>> S1 = 'abc' >>> S2 = 'xyz123' >>> map(None, S1, S2) # 2.X only: pads to len(longest) [('a', 'x'), ('b', 'y'), ('c', 'z'), (None, '1'), (None, '2'), (None,'3')] 408 | Chapter 13: while and for Loops
- 461. Thisexampleisusingadegenerateformofthemap built-in,whichisnolongersupported in 3.X. Normally, map takes a function and one or more sequence arguments and collects the results of calling the function with parallel items taken from the sequence(s). We’ll study map in detail in Chapter 19 and Chapter 20, but as a brief example, the following maps the built-in ord function across each item in a string and collects the results (like zip, map is a value generator in 3.X and so must be passed to list to collect all its results at once in 3.X only): >>> list(map(ord, 'spam')) [115, 112, 97, 109] This works the same as the following loop statement, but map is often quicker, as Chapter 21 will show: >>> res = [] >>> for c in 'spam': res.append(ord(c)) >>> res [115, 112, 97, 109] Version skew note: The degenerate form of map using a function argu- ment of None is no longer supported in Python 3.X, because it largely overlaps with zip (and was, frankly, a bit at odds with map’s function- application purpose). In 3.X, either use zip or write loop code to pad results yourself. In fact, we’ll see how to write such loop code in Chap- ter 20, after we’ve had a chance to study some additional iteration con- cepts. Dictionary construction with zip Let’s look at another zip use case. Chapter 8 suggested that the zip call used here can also be handy for generating dictionaries when the sets of keys and values must be computed at runtime. Now that we’re becoming proficient with zip, let’s explore more fully how it relates to dictionary construction. As you’ve learned, you can always create a dictionary by coding a dictionary literal, or by assigning to keys over time: >>> D1 = {'spam':1, 'eggs':3, 'toast':5} >>> D1 {'eggs': 3, 'toast': 5, 'spam': 1} >>> D1 = {} >>> D1['spam'] = 1 >>> D1['eggs'] = 3 >>> D1['toast'] = 5 What to do, though, if your program obtains dictionary keys and values in lists at runtime, after you’ve coded your script? For example, say you had the following keys and values lists, collected from a user, parsed from a file, or obtained from another dynamic source: Loop Coding Techniques | 409
- 462. >>> keys = ['spam', 'eggs', 'toast'] >>> vals = [1, 3, 5] One solution for turning those lists into a dictionary would be to zip the lists and step through them in parallel with a for loop: >>> list(zip(keys, vals)) [('spam', 1), ('eggs', 3), ('toast', 5)] >>> D2 = {} >>> for (k, v) in zip(keys, vals): D2[k] = v ... >>> D2 {'eggs': 3, 'toast': 5, 'spam': 1} It turns out, though, that in Python 2.2 and later you can skip the for loop altogether and simply pass the zipped keys/values lists to the built-in dict constructor call: >>> keys = ['spam', 'eggs', 'toast'] >>> vals = [1, 3, 5] >>> D3 = dict(zip(keys, vals)) >>> D3 {'eggs': 3, 'toast': 5, 'spam': 1} The built-in name dict is really a type name in Python (you’ll learn more about type names, and subclassing them, in Chapter 32). Calling it achieves something like a list- to-dictionary conversion, but it’s really an object construction request. In the next chapter we’ll explore the related but richer concept, the list comprehension, which builds lists in a single expression; we’ll also revisit Python 3.X and 2.7 dictionary comprehensions, an alternative to the dict call for zipped key/value pairs: >>> {k: v for (k, v) in zip(keys, vals)} {'eggs': 3, 'toast': 5, 'spam': 1} Generating Both Offsets and Items: enumerate Our final loop helper function is designed to support dual usage modes. Earlier, we discussed using range to generate the offsets of items in a string, rather than the items at those offsets. In some programs, though, we need both: the item to use, plus an offset as we go. Traditionally, this was coded with a simple for loop that also kept a counter of the current offset: >>> S = 'spam' >>> offset = 0 >>> for item in S: ... print(item, 'appears at offset', offset) ... offset += 1 ... s appears at offset 0 p appears at offset 1 a appears at offset 2 m appears at offset 3 410 | Chapter 13: while and for Loops
- 463. This works, but in all recent Python 2.X and 3.X releases (since 2.3) a new built-in named enumerate does the job for us—its net effect is to give loops a counter “for free,” without sacrificing the simplicity of automatic iteration: >>> S = 'spam' >>> for (offset, item) in enumerate(S): ... print(item, 'appears at offset', offset) ... s appears at offset 0 p appears at offset 1 a appears at offset 2 m appears at offset 3 The enumerate function returns a generator object—a kind of object that supports the iteration protocol that we will study in the next chapter and will discuss in more detail in the next part of the book. In short, it has a method called by thenext built-in function, which returns an (index, value) tuple each time through the loop. The for steps through these tuples automatically, which allows us to unpack their values with tuple assignment, much as we did for zip: >>> E = enumerate(S) >>> E <enumerate object at 0x0000000002A8B900> >>> next(E) (0, 's') >>> next(E) (1, 'p') >>> next(E) (2, 'a') We don’t normally see this machinery because all iteration contexts—including list comprehensions, the subject of Chapter 14—run the iteration protocol automatically: >>> [c * i for (i, c) in enumerate(S)] ['', 'p', 'aa', 'mmm'] >>> for (i, l) in enumerate(open('test.txt')): ... print('%s) %s' % (i, l.rstrip())) ... 0) aaaaaa 1) bbbbbb 2) cccccc To fully understand iteration concepts like enumerate, zip, and list comprehensions, though, we need to move on to the next chapter for a more formal dissection. Why You Will Care: Shell Commands and More An earlier sidebar showed loops applied to files. As briefly noted in Chapter 9, Python’s related os.popen call also gives a file-like interface, for reading the outputs of spawned shell commands. Now that we’ve studied looping statements in full, here’s an example of this tool in action—to run a shell command and read its standard output text, pass the command as a string to os popen, and read text from the file-like object it returns Loop Coding Techniques | 411
- 464. (if this triggers a Unicode encoding issue on your computer, Chapter 25’s discussion of currency symbols may apply): >>> import os >>> F = os.popen('dir') # Read line by line >>> F.readline() ' Volume in drive C has no label.n' >>> F = os.popen('dir') # Read by sized blocks >>> F.read(50) ' Volume in drive C has no label.n Volume Serial Nu' >>> os.popen('dir').readlines()[0] # Read all lines: index ' Volume in drive C has no label.n' >>> os.popen('dir').read()[:50] # Read all at once: slice ' Volume in drive C has no label.n Volume Serial Nu' >>> for line in os.popen('dir'): # File line iterator loop ... print(line.rstrip()) ... Volume in drive C has no label. Volume Serial Number is D093-D1F7 ...and so on... This runs a dir directory listing on Windows, but any program that can be started with a command line can be launched this way. We might use this scheme, for example, to displaytheoutputofthewindowssysteminfo command—os.system simplyrunsashell command, but os.popen also connects to its streams; both of the following show the shell command’s output in a simple console window, but the first might not in a GUI interface such as IDLE: >>> os.system('systeminfo') ...output in console, popup in IDLE... 0 >>> for line in os.popen('systeminfo'): print(line.rstrip()) Host Name: MARK-VAIO OS Name: Microsoft Windows 7 Professional OS Version: 6.1.7601 Service Pack 1 Build 7601 ...lots of system information text... And once we have a command’s output in text form, any string processing tool or technique applies—including display formatting and content parsing: # Formatted, limited display >>> for (i, line) in enumerate(os.popen('systeminfo')): ... if i == 4: break ... print('%05d) %s' % (i, line.rstrip())) ... 00000) 00001) Host Name: MARK-VAIO 00002) OS Name: Microsoft Windows 7 Professional 00003) OS Version: 6.1.7601 Service Pack 1 Build 7601 # Parse for specific lines, case neutral >>> for line in os.popen('systeminfo'): ... parts = line.split(':') ... if parts and parts[0].lower() == 'system type': ... print(parts[1].strip()) 412 | Chapter 13: while and for Loops
- 465. ... x64-based PC We’ll see os.popen in action again in Chapter 21, where we’ll deploy it to read the results of a constructed command line that times code alternatives, and in Chapter 25, where it will be used to compare outputs of scripts being tested. Tools like os.popen and os.system (and the subprocess module not shown here) allow you to leverage every command-line program on your computer, but you can also write emulators with in-process code. For example, simulating the Unix awk utility’s ability to strip columns out of text files is almost trivial in Python, and can become a reusable function in the process: # awk emulation: extract column 7 from whitespace-delimited file for val in [line.split()[6] for line in open('input.txt')]: print(val) # Same, but more explicit code that retains result col7 = [] for line in open('input.txt'): cols = line.split() col7.append(cols[6]) for item in col7: print(item) # Same, but a reusable function (see next part of book) def awker(file, col): return [line.rstrip().split()[col-1] for line in open(file)] print(awker('input.txt', 7)) # List of strings print(','.join(awker('input.txt', 7))) # Put commas between By itself, though, Python provides file-like access to a wide variety of data—including the text returned by websites and their pages identified by URL, though we’ll have to defer to Part V for more on the package import used here, and other resources for more on such tools in general (e.g., this works in 2.X, but uses urllib instead of urlib.request, and returns text strings): >>> from urllib.request import urlopen >>> for line in urlopen('http://home.rmi.net/~lutz'): ... print(line) ... b'<HTML>n' b'n' b'<HEAD>n' b"<TITLE>Mark Lutz's Book Support Site</TITLE>n" ...etc... Chapter Summary In this chapter, we explored Python’s looping statements as well as some concepts related to looping in Python. We looked at the while and for loop statements in depth, and we learned about their associated else clauses. We also studied the break and continue statements, which have meaning only inside loops, and met several built-in Chapter Summary | 413
- 466. tools commonly used in for loops, including range, zip, map, and enumerate, although some of the details regarding their roles as iterables in Python 3.X were intentionally cut short. In the next chapter, we continue the iteration story by discussing list comprehensions and the iteration protocol in Python—concepts strongly related to for loops. There, we’ll also give the rest of the picture behind the iterable tools we met here, such as range and zip, and study some of the subtleties of their operation. As always, though, before moving on let’s exercise what you’ve picked up here with a quiz. Test Your Knowledge: Quiz 1. What are the main functional differences between a while and a for? 2. What’s the difference between break and continue? 3. When is a loop’s else clause executed? 4. How can you code a counter-based loop in Python? 5. What can a range be used for in a for loop? Test Your Knowledge: Answers 1. The while loop is a general looping statement, but the for is designed to iterate across items in a sequence or other iterable. Although the while can imitate the for with counter loops, it takes more code and might run slower. 2. The break statement exits a loop immediately (you wind up below the entire while or for loop statement), and continue jumps back to the top of the loop (you wind up positioned just before the test in while or the next item fetch in for). 3. The else clause in a while or for loop will be run once as the loop is exiting, if the loop exits normally (without running into a break statement). A break exits the loop immediately, skipping the else part on the way out (if there is one). 4. Counter loops can be coded with a while statement that keeps track of the index manually, or with a for loop that uses the range built-in function to generate suc- cessive integer offsets. Neither is the preferred way to work in Python, if you need to simply step across all the items in a sequence. Instead, use a simple for loop instead, without range or counters, whenever possible; it will be easier to code and usually quicker to run. 5. The range built-in can be used in a for to implement a fixed number of repetitions, to scan by offsets instead of items at offsets, to skip successive items as you go, and to change a list while stepping across it. None of these roles requires range, and most have alternatives—scanning actual items, three-limit slices, and list compre- hensions are often better solutions today (despite the natural inclinations of ex–C programmers to want to count things!). 414 | Chapter 13: while and for Loops
- 467. CHAPTER 14 Iterations and Comprehensions In the prior chapter we met Python’s two looping statements, while and for. Although they can handle most repetitive tasks programs need to perform, the need to iterate over sequences is so common and pervasive that Python provides additional tools to make it simpler and more efficient. This chapter begins our exploration of these tools. Specifically, it presents the related concepts of Python’s iteration protocol, a method- call model used by the for loop, and fills in some details on list comprehensions, which are a close cousin to the for loop that applies an expression to items in an iterable. Because these tools are related to both the for loop and functions, we’ll take a two-pass approach to covering them in this book, along with a postscript: • This chapter introduces their basics in the context of looping tools, serving as something of a continuation of the prior chapter. • Chapter 20 revisits them in the context of function-based tools, and extends the topic to include built-in and user-defined generators. • Chapter 30 also provides a shorter final installment in this story, where we’ll learn about user-defined iterable objects coded with classes. In this chapter, we’ll also sample additional iteration tools in Python, and touch on the new iterables available in Python 3.X—where the notion of iterables grows even more pervasive. One note up front: some of the concepts presented in these chapters may seem ad- vanced at first glance. With practice, though, you’ll find that these tools are useful and powerful. Although never strictly required, because they’ve become commonplace in Python code, a basic understanding can also help if you must read programs written by others. 415
- 468. Iterations: A First Look In the preceding chapter, I mentioned that the for loop can work on any sequence type in Python, including lists, tuples, and strings, like this: >>> for x in [1, 2, 3, 4]: print(x ** 2, end=' ') # In 2.X: print x ** 2, ... 1 4 9 16 >>> for x in (1, 2, 3, 4): print(x ** 3, end=' ') ... 1 8 27 64 >>> for x in 'spam': print(x * 2, end=' ') ... ss pp aa mm Actually, the for loop turns out to be even more generic than this—it works on any iterable object. In fact, this is true of all iteration tools that scan objects from left to right in Python, including for loops, the list comprehensions we’ll study in this chapter, in membership tests, the map built-in function, and more. The concept of “iterable objects” is relatively recent in Python, but it has come to permeate the language’s design. It’s essentially a generalization of the notion of se- quences—an object is considered iterable if it is either a physically stored sequence, or an object that produces one result at a time in the context of an iteration tool like a for loop. In a sense, iterable objects include both physical sequences and virtual se- quences computed on demand. Terminology in this topic tends to be a bit loose. The terms “iterable” and “iterator” are sometimes used interchangeably to refer to an object that supports iteration in general. For clarity, this book has a very strong preference for using the term iterable to refer to an object that supports the iter call, and iterator to refer to an object returned by an iterable on iter that supports the next(I) call. Both these calls are defined ahead. That convention is not universal in either the Python world or this book, though; “iterator” is also sometimes used for tools that iterate. Chap- ter 20 extends this category with the term “generator”—which refers to objects that automatically support the iteration protocol, and hence are iterable—even though all iterables generate results! The Iteration Protocol: File Iterators One of the easiest ways to understand the iteration protocol is to see how it works with a built-in type such as the file. In this chapter, we’ll be using the following input file to demonstrate: >>> print(open('script2.py').read()) import sys 416 | Chapter 14: Iterations and Comprehensions
- 469. print(sys.path) x = 2 print(x ** 32) >>> open('script2.py').read() 'import sysnprint(sys.path)nx = 2nprint(x ** 32)n' Recall from Chapter 9 that open file objects have a method called readline, which reads one line of text from a file at a time—each time we call thereadline method, we advance to the next line. At the end of the file, an empty string is returned, which we can detect to break out of the loop: >>> f = open('script2.py') # Read a four-line script file in this directory >>> f.readline() # readline loads one line on each call 'import sysn' >>> f.readline() 'print(sys.path)n' >>> f.readline() 'x = 2n' >>> f.readline() # Last lines may have a n or not 'print(x ** 32)n' >>> f.readline() # Returns empty string at end-of-file '' However, files also have a method named __next__ in 3.X (and next in 2.X) that has a nearly identical effect—it returns the next line from a file each time it is called. The only noticeable difference is that __next__ raises a built-in StopIteration exception at end-of-file instead of returning an empty string: >>> f = open('script2.py') # __next__ loads one line on each call too >>> f.__next__() # But raises an exception at end-of-file 'import sysn' >>> f.__next__() # Use f.next() in 2.X, or next(f) in 2.X or 3.X 'print(sys.path)n' >>> f.__next__() 'x = 2n' >>> f.__next__() 'print(x ** 32)n' >>> f.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration This interface is most of what we call the iteration protocol in Python. Any object with a __next__ method to advance to a next result, which raises StopIteration at the end of the series of results, is considered an iterator in Python. Any such object may also be stepped through with a for loop or other iteration tool, because all iteration tools normally work internally by calling __next__ on each iteration and catching the StopIt eration exception to determine when to exit. As we’ll see in a moment, for some objects the full protocol includes an additional first step to call iter, but this isn’t required for files. Iterations: A First Look | 417
- 470. The net effect of this magic is that, as mentioned in Chapter 9 and Chapter 13, the best way to read a text file line by line today is to not read it at all—instead, allow the for loop to automatically call __next__ to advance to the next line on each iteration. The file object’s iterator will do the work of automatically loading lines as you go. The following, for example, reads a file line by line, printing the uppercase version of each line along the way, without ever explicitly reading from the file at all: >>> for line in open('script2.py'): # Use file iterators to read by lines ... print(line.upper(), end='') # Calls __next__, catches StopIteration ... IMPORT SYS PRINT(SYS.PATH) X = 2 PRINT(X ** 32) Notice that the print uses end='' here to suppress adding a n, because line strings already have one (without this, our output would be double-spaced; in 2.X, a trailing comma works the same as the end). This is considered the best way to read text files line by line today, for three reasons: it’s the simplest to code, might be the quickest to run, and is the best in terms of memory usage. The older, original way to achieve the same effect with a for loop is to call the file readlines method to load the file’s content into memory as a list of line strings: >>> for line in open('script2.py').readlines(): ... print(line.upper(), end='') ... IMPORT SYS PRINT(SYS.PATH) X = 2 PRINT(X ** 32) This readlines technique still works but is not considered the best practice today and performs poorly in terms of memory usage. In fact, because this version really does load the entire file into memory all at once, it will not even work for files too big to fit into the memory space available on your computer. By contrast, because it reads one line at a time, the iterator-based version is immune to such memory-explosion issues. The iterator version might run quicker too, though this can vary per release As mentioned in the prior chapter’s sidebar, “Why You Will Care: File Scan- ners” on page 400, it’s also possible to read a file line by line with a while loop: >>> f = open('script2.py') >>> while True: ... line = f.readline() ... if not line: break ... print(line.upper(), end='') ... ...same output... However, this may run slower than the iterator-based for loop version, because itera- tors run at C language speed inside Python, whereas the while loop version runs Python byte code through the Python virtual machine. Anytime we trade Python code for C 418 | Chapter 14: Iterations and Comprehensions
- 471. code, speed tends to increase. This is not an absolute truth, though, especially in Python 3.X; we’ll see timing techniques later in Chapter 21 for measuring the relative speed of alternatives like these.1 Version skew note: In Python 2.X, the iteration method is named X.next() instead of X.__next__(). For portability, a next(X) built-in function is also available in both Python 3.X and 2.X (2.6 and later), and calls X.__next__() in 3.X and X.next() in 2.X. Apart from method names, iteration works the same in 2.X and 3.X in all other ways. In 2.6 and 2.7, simply use X.next() or next(X) for manual iterations instead of 3.X’s X.__next__(); prior to 2.6, use X.next() calls instead of next(X). Manual Iteration: iter and next To simplify manual iteration code, Python 3.X also provides a built-in function, next, that automatically calls an object’s __next__ method. Per the preceding note, this call also is supported on Python 2.X for portability. Given an iterator object X, the call next(X) is the same as X.__next__() on 3.X (and X.next() on 2.X), but is noticeably simpler and more version-neutral. With files, for instance, either form may be used: >>> f = open('script2.py') >>> f.__next__() # Call iteration method directly 'import sysn' >>> f.__next__() 'print(sys.path)n' >>> f = open('script2.py') >>> next(f) # The next(f) built-in calls f.__next__() in 3.X 'import sysn' >>> next(f) # next(f) => [3.X: f.__next__()], [2.X: f.next()] 'print(sys.path)n' Technically, there is one more piece to the iteration protocol alluded to earlier. When the for loop begins, it first obtains an iterator from the iterable object by passing it to the iter built-in function; the object returned by iter in turn has the required next method. The iter function internally runs the __iter__ method, much like next and __next__. 1. Spoiler alert: the file iterator still appears to be slightly faster than readlines and at least 30% faster than the while loop in both 2.7 and 3.3 on tests I’ve run with this chapter’s code on a 1,000-line file (while is twice as slow on 2.7). The usual benchmarking caveats apply—this is true only for my Pythons, my computer, and my test file, and Python 3.X complicates such analyses by rewriting I/O libraries to support Unicode text and be less system-dependent. Chapter 21 covers tools and techniques you can use to time these loop statements on your own. Iterations: A First Look | 419
- 472. The full iteration protocol As a more formal definition, Figure 14-1 sketches this full iteration protocol, used by every iteration tool in Python, and supported by a wide variety of object types. It’s really based on two objects, used in two distinct steps by iteration tools: • The iterable object you request iteration for, whose __iter__ is run by iter • The iterator object returned by the iterable that actually produces values during the iteration, whose __next__ is run by next and raises StopIteration when finished producing results These steps are orchestrated automatically by iteration tools in most cases, but it helps to understand these two objects’ roles. For example, in some cases these two objects are the same when only a single scan is supported (e.g., files), and the iterator object is often temporary, used internally by the iteration tool. Moreover, some objects are both an iteration context tool (they iterate) and an iterable object (their results are iterable)—including Chapter 20’s generator expressions, and map and zip in Python 3.X. As we’ll see ahead, more tools become iterables in 3.X— including map, zip, range, and some dictionary methods—to avoid constructing result lists in memory all at once. Figure 14-1. The Python iteration protocol, used by for loops, comprehensions, maps, and more, and supported by files, lists, dictionaries, Chapter 20’s generators, and more. Some objects are both iteration context and iterable object, such as generator expressions and 3.X’s flavors of some tools (such as map and zip). Some objects are both iterable and iterator, returning themselves for the iter() call, which is then a no-op. In actual code, the protocol’s first step becomes obvious if we look at how for loops internally process built-in sequence types such as lists: >>> L = [1, 2, 3] >>> I = iter(L) # Obtain an iterator object from an iterable >>> I.__next__() # Call iterator's next to advance to next item 1 420 | Chapter 14: Iterations and Comprehensions
- 473. >>> I.__next__() # Or use I.next() in 2.X, next(I) in either line 2 >>> I.__next__() 3 >>> I.__next__() ...error text omitted... StopIteration This initial step is not required for files, because a file object is its own iterator. Because they support just one iteration (they can’t seek backward to support multiple active scans), files have their own __next__ method and do not need to return a different object that does: >>> f = open('script2.py') >>> iter(f) is f True >>> iter(f) is f.__iter__() True >>> f.__next__() 'import sysn' Lists and many other built-in objects, though, are not their own iterators because they do support multiple open iterations—for example, there may be multiple iterations in nested loops all at different positions. For such objects, we must call iter to start iter- ating: >>> L = [1, 2, 3] >>> iter(L) is L False >>> L.__next__() AttributeError: 'list' object has no attribute '__next__' >>> I = iter(L) >>> I.__next__() 1 >>> next(I) # Same as I.__next__() 2 Manual iteration Although Python iteration tools call these functions automatically, we can use them to apply the iteration protocol manually, too. The following interaction demonstrates the equivalence between automatic and manual iteration:2 >>> L = [1, 2, 3] >>> >>> for X in L: # Automatic iteration ... print(X ** 2, end=' ') # Obtains iter, calls __next__, catches exceptions ... 1 4 9 2. Technically speaking, the for loop calls the internal equivalent of I.__next__, instead of the next(I) used here, though there is rarely any difference between the two. Your manual iterations can generally use either call scheme. Iterations: A First Look | 421
- 474. >>> I = iter(L) # Manual iteration: what for loops usually do >>> while True: ... try: # try statement catches exceptions ... X = next(I) # Or call I.__next__ in 3.X ... except StopIteration: ... break ... print(X ** 2, end=' ') ... 1 4 9 To understand this code, you need to know that try statements run an action and catch exceptions that occur while the action runs (we met exceptions briefly in Chapter 11 but will explore them in depth in Part VII). I should also note that for loops and other iteration contexts can sometimes work differently for user-defined classes, repeatedly indexing an object instead of running the iteration protocol, but prefer the iteration protocol if it’s used. We’ll defer that story until we study class operator overloading in Chapter 30. Other Built-in Type Iterables Besides files and physical sequences like lists, other types have useful iterators as well. The classic way to step through the keys of a dictionary, for example, is to request its keys list explicitly: >>> D = {'a':1, 'b':2, 'c':3} >>> for key in D.keys(): ... print(key, D[key]) ... a 1 b 2 c 3 In recent versions of Python, though, dictionaries are iterables with an iterator that automatically returns one key at a time in an iteration context: >>> I = iter(D) >>> next(I) 'a' >>> next(I) 'b' >>> next(I) 'c' >>> next(I) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration The net effect is that we no longer need to call the keys method to step through dic- tionary keys—the for loop will use the iteration protocol to grab one key each time through: 422 | Chapter 14: Iterations and Comprehensions
- 475. >>> for key in D: ... print(key, D[key]) ... a 1 b 2 c 3 We can’t delve into their details here, but other Python object types also support the iteration protocol and thus may be used in for loops too. For instance, shelves (an access-by-key filesystem for Python objects) and the results from os.popen (a tool for reading the output of shell commands, which we met in the preceding chapter) are iterable as well: >>> import os >>> P = os.popen('dir') >>> P.__next__() ' Volume in drive C has no label.n' >>> P.__next__() ' Volume Serial Number is D093-D1F7n' >>> next(P) TypeError: _wrap_close object is not an iterator Notice that popen objects themselves support a P.next() method in Python 2.X. In 3.X, they support the P.__next__() method, but not the next(P) built-in. Since the latter is defined to call the former, this may seem unusual, though both calls work correctly if we use the full iteration protocol employed automatically by for loops and other iter- ation contexts, with its top-level iter call (this performs internal steps required to also support next calls for this object): >>> P = os.popen('dir') >>> I = iter(P) >>> next(I) ' Volume in drive C has no label.n' >>> I.__next__() ' Volume Serial Number is D093-D1F7n' Also in the systems domain, the standard directory walker in Python, os.walk, is sim- ilarly iterable, but we’ll save an example until Chapter 20’s coverage of this tool’s basis —generators and yield. The iteration protocol also is the reason that we’ve had to wrap some results in a list call to see their values all at once. Objects that are iterable return results one at a time, not in a physical list: >>> R = range(5) >>> R # Ranges are iterables in 3.X range(0, 5) >>> I = iter(R) # Use iteration protocol to produce results >>> next(I) 0 >>> next(I) 1 >>> list(range(5)) # Or use list to collect all results at once [0, 1, 2, 3, 4] Iterations: A First Look | 423
- 476. Note that the list call here is not required in 2.X (where range builds a real list), and is not needed in 3.X for contexts where iteration happens automatically (such as within for loops). It is needed for displaying values here in 3.X, though, and may also be required when list-like behavior or multiple scans are required for objects that produce results on demand in 2.X or 3.X (more on this ahead). Now that you have a better understanding of this protocol, you should be able to see how it explains why the enumerate tool introduced in the prior chapter works the way it does: >>> E = enumerate('spam') # enumerate is an iterable too >>> E <enumerate object at 0x00000000029B7678> >>> I = iter(E) >>> next(I) # Generate results with iteration protocol (0, 's') >>> next(I) # Or use list to force generation to run (1, 'p') >>> list(enumerate('spam')) [(0, 's'), (1, 'p'), (2, 'a'), (3, 'm')] We don’t normally see this machinery because for loops run it for us automatically to step through results. In fact, everything that scans left to right in Python employs the iteration protocol in the same way—including the topic of the next section. List Comprehensions: A First Detailed Look Now that we’ve seen how the iterati